Km1hcC50eHQqICAgICAgIEZvciBWaW0gdmVyc2lvbiA3LjMuICBMYXN0IGNoYW5nZTogMjAxMSBNYXkgMTAKCgoJCSAgVklNIFJFRkVSRU5DRSBNQU5VQUwgICAgYnkgQnJhbSBNb29sZW5hYXIKCgpLZXkgbWFwcGluZywgYWJicmV2aWF0aW9ucyBhbmQgdXNlci1kZWZpbmVkIGNvbW1hbmRzLgoKVGhpcyBzdWJqZWN0IGlzIGludHJvZHVjZWQgaW4gc2VjdGlvbnMgfDA1LjN8LCB8MjQuN3wgYW5kIHw0MC4xfCBvZiB0aGUgdXNlcgptYW51YWwuCgoxLiBLZXkgbWFwcGluZwkJCXxrZXktbWFwcGluZ3wKICAgMS4xIE1BUCBDT01NQU5EUwkJCXw6bWFwLWNvbW1hbmRzfAogICAxLjIgU3BlY2lhbCBhcmd1bWVudHMJCXw6bWFwLWFyZ3VtZW50c3wKICAgMS4zIE1hcHBpbmcgYW5kIG1vZGVzCQl8Om1hcC1tb2Rlc3wKICAgMS40IExpc3RpbmcgbWFwcGluZ3MJCQl8bWFwLWxpc3Rpbmd8CiAgIDEuNSBNYXBwaW5nIHNwZWNpYWwga2V5cwkJfDptYXAtc3BlY2lhbC1rZXlzfAogICAxLjYgU3BlY2lhbCBjaGFyYWN0ZXJzCQl8Om1hcC1zcGVjaWFsLWNoYXJzfAogICAxLjcgV2hhdCBrZXlzIHRvIG1hcAkJCXxtYXAtd2hpY2gta2V5c3wKICAgMS44IEV4YW1wbGVzCQkJCXxtYXAtZXhhbXBsZXN8CiAgIDEuOSBVc2luZyBtYXBwaW5ncwkJCXxtYXAtdHlwaW5nfAogICAxLjEwIE1hcHBpbmcgYWx0LWtleXMJCXw6bWFwLWFsdC1rZXlzfAogICAxLjExIE1hcHBpbmcgYW4gb3BlcmF0b3IJCXw6bWFwLW9wZXJhdG9yfAoyLiBBYmJyZXZpYXRpb25zCQl8YWJicmV2aWF0aW9uc3wKMy4gTG9jYWwgbWFwcGluZ3MgYW5kIGZ1bmN0aW9ucwl8c2NyaXB0LWxvY2FsfAo0LiBVc2VyLWRlZmluZWQgY29tbWFuZHMJfHVzZXItY29tbWFuZHN8Cgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KMS4gS2V5IG1hcHBpbmcJCQkJKmtleS1tYXBwaW5nKiAqbWFwcGluZyogKm1hY3JvKgoKS2V5IG1hcHBpbmcgaXMgdXNlZCB0byBjaGFuZ2UgdGhlIG1lYW5pbmcgb2YgdHlwZWQga2V5cy4gIFRoZSBtb3N0IGNvbW1vbiB1c2UKaXMgdG8gZGVmaW5lIGEgc2VxdWVuY2UgY29tbWFuZHMgZm9yIGEgZnVuY3Rpb24ga2V5LiAgRXhhbXBsZTogPgoKCTptYXAgPEYyPiBhPEMtUj49c3RyZnRpbWUoIiVjIik8Q1I+PEVzYz4KClRoaXMgYXBwZW5kcyB0aGUgY3VycmVudCBkYXRlIGFuZCB0aW1lIGFmdGVyIHRoZSBjdXJzb3IgKGluIDw+IG5vdGF0aW9uIHw8PnwpLgoKCjEuMSBNQVAgQ09NTUFORFMJCQkJCSo6bWFwLWNvbW1hbmRzKgoKVGhlcmUgYXJlIGNvbW1hbmRzIHRvIGVudGVyIG5ldyBtYXBwaW5ncywgcmVtb3ZlIG1hcHBpbmdzIGFuZCBsaXN0IG1hcHBpbmdzLgpTZWUgfG1hcC1vdmVydmlld3wgZm9yIHRoZSB2YXJpb3VzIGZvcm1zIG9mICJtYXAiIGFuZCB0aGVpciByZWxhdGlvbnNoaXBzIHdpdGgKbW9kZXMuCgp7bGhzfQltZWFucyBsZWZ0LWhhbmQtc2lkZQkqe2xoc30qCntyaHN9CW1lYW5zIHJpZ2h0LWhhbmQtc2lkZQkqe3Joc30qCgo6bWFwCXtsaHN9IHtyaHN9CQl8bWFwbW9kZS1udm98CQkqOm1hcCoKOm5tW2FwXQl7bGhzfSB7cmhzfQkJfG1hcG1vZGUtbnwJCSo6bm0qICo6bm1hcCoKOnZtW2FwXQl7bGhzfSB7cmhzfQkJfG1hcG1vZGUtdnwJCSo6dm0qICo6dm1hcCoKOnhtW2FwXQl7bGhzfSB7cmhzfQkJfG1hcG1vZGUteHwJCSo6eG0qICo6eG1hcCoKOnNtYXAJe2xoc30ge3Joc30JCXxtYXBtb2RlLXN8CQkgICAgICAqOnNtYXAqCjpvbVthcF0Je2xoc30ge3Joc30JCXxtYXBtb2RlLW98CQkqOm9tKiAqOm9tYXAqCjptYXAhCXtsaHN9IHtyaHN9CQl8bWFwbW9kZS1pY3wJCSo6bWFwISoKOmltW2FwXQl7bGhzfSB7cmhzfQkJfG1hcG1vZGUtaXwJCSo6aW0qICo6aW1hcCoKOmxtW2FwXQl7bGhzfSB7cmhzfQkJfG1hcG1vZGUtbHwJCSo6bG0qICo6bG1hcCoKOmNtW2FwXQl7bGhzfSB7cmhzfQkJfG1hcG1vZGUtY3wJCSo6Y20qICo6Y21hcCoKCQkJTWFwIHRoZSBrZXkgc2VxdWVuY2Uge2xoc30gdG8ge3Joc30gZm9yIHRoZSBtb2RlcwoJCQl3aGVyZSB0aGUgbWFwIGNvbW1hbmQgYXBwbGllcy4gIFRoZSByZXN1bHQsIGluY2x1ZGluZwoJCQl7cmhzfSwgaXMgdGhlbiBmdXJ0aGVyIHNjYW5uZWQgZm9yIG1hcHBpbmdzLiAgVGhpcwoJCQlhbGxvd3MgZm9yIG5lc3RlZCBhbmQgcmVjdXJzaXZlIHVzZSBvZiBtYXBwaW5ncy4KCgo6bm9bcmVtYXBdICB7bGhzfSB7cmhzfQkJfG1hcG1vZGUtbnZvfAkJKjpubyogICo6bm9yZW1hcCoKOm5uW29yZW1hcF0ge2xoc30ge3Joc30JCXxtYXBtb2RlLW58CQkqOm5uKiAgKjpubm9yZW1hcCoKOnZuW29yZW1hcF0ge2xoc30ge3Joc30JCXxtYXBtb2RlLXZ8CQkqOnZuKiAgKjp2bm9yZW1hcCoKOnhuW29yZW1hcF0ge2xoc30ge3Joc30JCXxtYXBtb2RlLXh8CQkqOnhuKiAgKjp4bm9yZW1hcCoKOnNub3JbZW1hcF0ge2xoc30ge3Joc30JCXxtYXBtb2RlLXN8CQkqOnNub3IqICo6c25vcmVtYXAqCjpvbm9bcmVtYXBdIHtsaHN9IHtyaHN9CQl8bWFwbW9kZS1vfAkJKjpvbm8qICo6b25vcmVtYXAqCjpub1tyZW1hcF0hIHtsaHN9IHtyaHN9CQl8bWFwbW9kZS1pY3wJCSo6bm8hKiAqOm5vcmVtYXAhKgo6aW5vW3JlbWFwXSB7bGhzfSB7cmhzfQkJfG1hcG1vZGUtaXwJCSo6aW5vKiAqOmlub3JlbWFwKgo6bG5bb3JlbWFwXSB7bGhzfSB7cmhzfQkJfG1hcG1vZGUtbHwJCSo6bG4qICAqOmxub3JlbWFwKgo6Y25vW3JlbWFwXSB7bGhzfSB7cmhzfQkJfG1hcG1vZGUtY3wJCSo6Y25vKiAqOmNub3JlbWFwKgoJCQlNYXAgdGhlIGtleSBzZXF1ZW5jZSB7bGhzfSB0byB7cmhzfSBmb3IgdGhlIG1vZGVzCgkJCXdoZXJlIHRoZSBtYXAgY29tbWFuZCBhcHBsaWVzLiAgRGlzYWxsb3cgbWFwcGluZyBvZgoJCQl7cmhzfSwgdG8gYXZvaWQgbmVzdGVkIGFuZCByZWN1cnNpdmUgbWFwcGluZ3MuICBPZnRlbgoJCQl1c2VkIHRvIHJlZGVmaW5lIGEgY29tbWFuZC4gIHtub3QgaW4gVml9CgoKOnVubVthcF0gIHtsaHN9CQkJfG1hcG1vZGUtbnZvfAkJKjp1bm0qICAqOnVubWFwKgo6bnVuW21hcF0ge2xoc30JCQl8bWFwbW9kZS1ufAkJKjpudW4qICAqOm51bm1hcCoKOnZ1W25tYXBdIHtsaHN9CQkJfG1hcG1vZGUtdnwJCSo6dnUqICAgKjp2dW5tYXAqCjp4dVtubWFwXSB7bGhzfQkJCXxtYXBtb2RlLXh8CQkqOnh1KiAgICo6eHVubWFwKgo6c3VubVthcF0ge2xoc30JCQl8bWFwbW9kZS1zfAkJKjpzdW5tKiAqOnN1bm1hcCoKOm91W25tYXBdIHtsaHN9CQkJfG1hcG1vZGUtb3wJCSo6b3UqICAgKjpvdW5tYXAqCjp1bm1bYXBdISB7bGhzfQkJCXxtYXBtb2RlLWljfAkJKjp1bm0hKiAqOnVubWFwISoKOml1W25tYXBdIHtsaHN9CQkJfG1hcG1vZGUtaXwJCSo6aXUqICAgKjppdW5tYXAqCjpsdVtubWFwXSB7bGhzfQkJCXxtYXBtb2RlLWx8CQkqOmx1KiAgICo6bHVubWFwKgo6Y3Vbbm1hcF0ge2xoc30JCQl8bWFwbW9kZS1jfAkJKjpjdSogICAqOmN1bm1hcCoKCQkJUmVtb3ZlIHRoZSBtYXBwaW5nIG9mIHtsaHN9IGZvciB0aGUgbW9kZXMgd2hlcmUgdGhlCgkJCW1hcCBjb21tYW5kIGFwcGxpZXMuICBUaGUgbWFwcGluZyBtYXkgcmVtYWluIGRlZmluZWQKCQkJZm9yIG90aGVyIG1vZGVzIHdoZXJlIGl0IGFwcGxpZXMuCgkJCU5vdGU6IFRyYWlsaW5nIHNwYWNlcyBhcmUgaW5jbHVkZWQgaW4gdGhlIHtsaHN9LiAgVGhpcwoJCQl1bm1hcCBkb2VzIE5PVCB3b3JrOiA+CgkJCQk6bWFwIEBAIGZvbwoJCQkJOnVubWFwIEBAIHwgcHJpbnQKCjptYXBjW2xlYXJdCQkJfG1hcG1vZGUtbnZvfAkJKjptYXBjKiAgICo6bWFwY2xlYXIqCjpubWFwY1tsZWFyXQkJCXxtYXBtb2RlLW58CQkqOm5tYXBjKiAgKjpubWFwY2xlYXIqCjp2bWFwY1tsZWFyXQkJCXxtYXBtb2RlLXZ8CQkqOnZtYXBjKiAgKjp2bWFwY2xlYXIqCjp4bWFwY1tsZWFyXQkJCXxtYXBtb2RlLXh8CQkqOnhtYXBjKiAgKjp4bWFwY2xlYXIqCjpzbWFwY1tsZWFyXQkJCXxtYXBtb2RlLXN8CQkqOnNtYXBjKiAgKjpzbWFwY2xlYXIqCjpvbWFwY1tsZWFyXQkJCXxtYXBtb2RlLW98CQkqOm9tYXBjKiAgKjpvbWFwY2xlYXIqCjptYXBjW2xlYXJdIQkJCXxtYXBtb2RlLWljfAkJKjptYXBjISogICo6bWFwY2xlYXIhKgo6aW1hcGNbbGVhcl0JCQl8bWFwbW9kZS1pfAkJKjppbWFwYyogICo6aW1hcGNsZWFyKgo6bG1hcGNbbGVhcl0JCQl8bWFwbW9kZS1sfAkJKjpsbWFwYyogICo6bG1hcGNsZWFyKgo6Y21hcGNbbGVhcl0JCQl8bWFwbW9kZS1jfAkJKjpjbWFwYyogICo6Y21hcGNsZWFyKgoJCQlSZW1vdmUgQUxMIG1hcHBpbmdzIGZvciB0aGUgbW9kZXMgd2hlcmUgdGhlIG1hcAoJCQljb21tYW5kIGFwcGxpZXMuICB7bm90IGluIFZpfQoJCQlXYXJuaW5nOiBUaGlzIGFsc28gcmVtb3ZlcyB0aGUgZGVmYXVsdCBtYXBwaW5ncy4KCjptYXAJCQkJfG1hcG1vZGUtbnZvfAo6bm1bYXBdCQkJCXxtYXBtb2RlLW58Cjp2bVthcF0JCQkJfG1hcG1vZGUtdnwKOnhtW2FwXQkJCQl8bWFwbW9kZS14fAo6c21bYXBdCQkJCXxtYXBtb2RlLXN8CjpvbVthcF0JCQkJfG1hcG1vZGUtb3wKOm1hcCEJCQkJfG1hcG1vZGUtaWN8CjppbVthcF0JCQkJfG1hcG1vZGUtaXwKOmxtW2FwXQkJCQl8bWFwbW9kZS1sfAo6Y21bYXBdCQkJCXxtYXBtb2RlLWN8CgkJCUxpc3QgYWxsIGtleSBtYXBwaW5ncyBmb3IgdGhlIG1vZGVzIHdoZXJlIHRoZSBtYXAKCQkJY29tbWFuZCBhcHBsaWVzLiAgTm90ZSB0aGF0ICI6bWFwIiBhbmQgIjptYXAhIiBhcmUKCQkJdXNlZCBtb3N0IG9mdGVuLCBiZWNhdXNlIHRoZXkgaW5jbHVkZSB0aGUgb3RoZXIgbW9kZXMuCgo6bWFwICAgIHtsaHN9CQkJfG1hcG1vZGUtbnZvfAkJKjptYXBfbCoKOm5tW2FwXSB7bGhzfQkJCXxtYXBtb2RlLW58CQkqOm5tYXBfbCoKOnZtW2FwXSB7bGhzfQkJCXxtYXBtb2RlLXZ8CQkqOnZtYXBfbCoKOnhtW2FwXSB7bGhzfQkJCXxtYXBtb2RlLXh8CQkqOnhtYXBfbCoKOnNtW2FwXSB7bGhzfQkJCXxtYXBtb2RlLXN8CQkqOnNtYXBfbCoKOm9tW2FwXSB7bGhzfQkJCXxtYXBtb2RlLW98CQkqOm9tYXBfbCoKOm1hcCEgICB7bGhzfQkJCXxtYXBtb2RlLWljfAkJKjptYXBfbCEqCjppbVthcF0ge2xoc30JCQl8bWFwbW9kZS1pfAkJKjppbWFwX2wqCjpsbVthcF0ge2xoc30JCQl8bWFwbW9kZS1sfAkJKjpsbWFwX2wqCjpjbVthcF0ge2xoc30JCQl8bWFwbW9kZS1jfAkJKjpjbWFwX2wqCgkJCUxpc3QgdGhlIGtleSBtYXBwaW5ncyBmb3IgdGhlIGtleSBzZXF1ZW5jZXMgc3RhcnRpbmcKCQkJd2l0aCB7bGhzfSBpbiB0aGUgbW9kZXMgd2hlcmUgdGhlIG1hcCBjb21tYW5kIGFwcGxpZXMuCgkJCXtub3QgaW4gVml9CgpUaGVzZSBjb21tYW5kcyBhcmUgdXNlZCB0byBtYXAgYSBrZXkgb3Iga2V5IHNlcXVlbmNlIHRvIGEgc3RyaW5nIG9mCmNoYXJhY3RlcnMuICBZb3UgY2FuIHVzZSB0aGlzIHRvIHB1dCBjb21tYW5kIHNlcXVlbmNlcyB1bmRlciBmdW5jdGlvbiBrZXlzLAp0cmFuc2xhdGUgb25lIGtleSBpbnRvIGFub3RoZXIsIGV0Yy4gIFNlZSB8Om1rZXhyY3wgZm9yIGhvdyB0byBzYXZlIGFuZApyZXN0b3JlIHRoZSBjdXJyZW50IG1hcHBpbmdzLgoKCQkJCQkJCSptYXAtYW1iaWd1b3VzKgpXaGVuIHR3byBtYXBwaW5ncyBzdGFydCB3aXRoIHRoZSBzYW1lIHNlcXVlbmNlIG9mIGNoYXJhY3RlcnMsIHRoZXkgYXJlCmFtYmlndW91cy4gIEV4YW1wbGU6ID4KCTppbWFwIGFhIGZvbwoJOmltYXAgYWFhIGJhcgpXaGVuIFZpbSBoYXMgcmVhZCAiYWEiLCBpdCB3aWxsIG5lZWQgdG8gZ2V0IGFub3RoZXIgY2hhcmFjdGVyIHRvIGJlIGFibGUgdG8KZGVjaWRlIGlmICJhYSIgb3IgImFhYSIgc2hvdWxkIGJlIG1hcHBlZC4gIFRoaXMgbWVhbnMgdGhhdCBhZnRlciB0eXBpbmcgImFhIgp0aGF0IG1hcHBpbmcgd29uJ3QgZ2V0IGV4cGFuZGVkIHlldCwgVmltIGlzIHdhaXRpbmcgZm9yIGFub3RoZXIgY2hhcmFjdGVyLgpJZiB5b3UgdHlwZSBhIHNwYWNlLCB0aGVuICJmb28iIHdpbGwgZ2V0IGluc2VydGVkLCBwbHVzIHRoZSBzcGFjZS4gIElmIHlvdQp0eXBlICJhIiwgdGhlbiAiYmFyIiB3aWxsIGdldCBpbnNlcnRlZC4Ke1ZpIGRvZXMgbm90IGFsbG93IGFtYmlndW91cyBtYXBwaW5nc30KCgoxLjIgU1BFQ0lBTCBBUkdVTUVOVFMJCQkJCSo6bWFwLWFyZ3VtZW50cyoKCiI8YnVmZmVyPiIsICI8c2lsZW50PiIsICI8c3BlY2lhbD4iLCAiPHNjcmlwdD4iLCAiPGV4cHI+IiBhbmQgIjx1bmlxdWU+IiBjYW4KYmUgdXNlZCBpbiBhbnkgb3JkZXIuICBUaGV5IG11c3QgYXBwZWFyIHJpZ2h0IGFmdGVyIHRoZSBjb21tYW5kLCBiZWZvcmUgYW55Cm90aGVyIGFyZ3VtZW50cy4KCgkJCQkqOm1hcC1sb2NhbCogKjptYXAtPGJ1ZmZlcj4qICpFMjI0KiAqRTIyNSoKSWYgdGhlIGZpcnN0IGFyZ3VtZW50IHRvIG9uZSBvZiB0aGVzZSBjb21tYW5kcyBpcyAiPGJ1ZmZlcj4iIHRoZSBtYXBwaW5nIHdpbGwKYmUgZWZmZWN0aXZlIGluIHRoZSBjdXJyZW50IGJ1ZmZlciBvbmx5LiAgRXhhbXBsZTogPgoJOm1hcCA8YnVmZmVyPiAgLHcgIC9bLiw7XTxDUj4KVGhlbiB5b3UgY2FuIG1hcCAiLHciIHRvIHNvbWV0aGluZyBlbHNlIGluIGFub3RoZXIgYnVmZmVyOiA+Cgk6bWFwIDxidWZmZXI+ICAsdyAgL1sjJiFdPENSPgpUaGUgbG9jYWwgYnVmZmVyIG1hcHBpbmdzIGFyZSB1c2VkIGJlZm9yZSB0aGUgZ2xvYmFsIG9uZXMuClRoZSAiPGJ1ZmZlcj4iIGFyZ3VtZW50IGNhbiBhbHNvIGJlIHVzZWQgdG8gY2xlYXIgbWFwcGluZ3M6ID4KCTp1bm1hcCA8YnVmZmVyPiAsdwoJOm1hcGNsZWFyIDxidWZmZXI+CkxvY2FsIG1hcHBpbmdzIGFyZSBhbHNvIGNsZWFyZWQgd2hlbiBhIGJ1ZmZlciBpcyBkZWxldGVkLCBidXQgbm90IHdoZW4gaXQgaXMKdW5sb2FkZWQuICBKdXN0IGxpa2UgbG9jYWwgb3B0aW9uIHZhbHVlcy4KCgkJCQkJCSo6bWFwLTxzaWxlbnQ+KiAqOm1hcC1zaWxlbnQqClRvIGRlZmluZSBhIG1hcHBpbmcgd2hpY2ggd2lsbCBub3QgYmUgZWNob2VkIG9uIHRoZSBjb21tYW5kIGxpbmUsIGFkZAoiPHNpbGVudD4iIGFzIHRoZSBmaXJzdCBhcmd1bWVudC4gIEV4YW1wbGU6ID4KCTptYXAgPHNpbGVudD4gLGggL0hlYWRlcjxDUj4KVGhlIHNlYXJjaCBzdHJpbmcgd2lsbCBub3QgYmUgZWNob2VkIHdoZW4gdXNpbmcgdGhpcyBtYXBwaW5nLiAgTWVzc2FnZXMgZnJvbQp0aGUgZXhlY3V0ZWQgY29tbWFuZCBhcmUgc3RpbGwgZ2l2ZW4gdGhvdWdoLiAgVG8gc2h1dCB0aGVtIHVwIHRvbywgYWRkIGEKIjpzaWxlbnQiIGluIHRoZSBleGVjdXRlZCBjb21tYW5kOiA+Cgk6bWFwIDxzaWxlbnQ+ICxoIDpleGUgIjpzaWxlbnQgbm9ybWFsIC9IZWFkZXJcciI8Q1I+ClByb21wdHMgd2lsbCBzdGlsbCBiZSBnaXZlbiwgZS5nLiwgZm9yIGlucHV0ZGlhbG9nKCkuClVzaW5nICI8c2lsZW50PiIgZm9yIGFuIGFiYnJldmlhdGlvbiBpcyBwb3NzaWJsZSwgYnV0IHdpbGwgY2F1c2UgcmVkcmF3aW5nIG9mCnRoZSBjb21tYW5kIGxpbmUgdG8gZmFpbC4KCgkJCQkJCSo6bWFwLTxzcGVjaWFsPiogKjptYXAtc3BlY2lhbCoKRGVmaW5lIGEgbWFwcGluZyB3aXRoIDw+IG5vdGF0aW9uIGZvciBzcGVjaWFsIGtleXMsIGV2ZW4gdGhvdWdoIHRoZSAiPCIgZmxhZwptYXkgYXBwZWFyIGluICdjcG9wdGlvbnMnLiAgVGhpcyBpcyB1c2VmdWwgaWYgdGhlIHNpZGUgZWZmZWN0IG9mIHNldHRpbmcKJ2Nwb3B0aW9ucycgaXMgbm90IGRlc2lyZWQuICBFeGFtcGxlOiA+Cgk6bWFwIDxzcGVjaWFsPiA8RjEyPiAvSGVhZGVyPENSPgo8CgkJCQkJCSo6bWFwLTxzY3JpcHQ+KiAqOm1hcC1zY3JpcHQqCklmIHRoZSBmaXJzdCBhcmd1bWVudCB0byBvbmUgb2YgdGhlc2UgY29tbWFuZHMgaXMgIjxzY3JpcHQ+IiBhbmQgaXQgaXMgdXNlZCB0bwpkZWZpbmUgYSBuZXcgbWFwcGluZyBvciBhYmJyZXZpYXRpb24sIHRoZSBtYXBwaW5nIHdpbGwgb25seSByZW1hcCBjaGFyYWN0ZXJzCmluIHRoZSB7cmhzfSB1c2luZyBtYXBwaW5ncyB0aGF0IHdlcmUgZGVmaW5lZCBsb2NhbCB0byBhIHNjcmlwdCwgc3RhcnRpbmcgd2l0aAoiPFNJRD4iLiAgVGhpcyBjYW4gYmUgdXNlZCB0byBhdm9pZCB0aGF0IG1hcHBpbmdzIGZyb20gb3V0c2lkZSBhIHNjcmlwdAppbnRlcmZlcmUgKGUuZy4sIHdoZW4gQ1RSTC1WIGlzIHJlbWFwcGVkIGluIG1zd2luLnZpbSksIGJ1dCBkbyB1c2Ugb3RoZXIKbWFwcGluZ3MgZGVmaW5lZCBpbiB0aGUgc2NyaXB0LgpOb3RlOiAiOm1hcCA8c2NyaXB0PiIgYW5kICI6bm9yZW1hcCA8c2NyaXB0PiIgZG8gdGhlIHNhbWUgdGhpbmcuICBUaGUKIjxzY3JpcHQ+IiBvdmVycnVsZXMgdGhlIGNvbW1hbmQgbmFtZS4gIFVzaW5nICI6bm9yZW1hcCA8c2NyaXB0PiIgaXMKcHJlZmVycmVkLCBiZWNhdXNlIGl0J3MgY2xlYXJlciB0aGF0IHJlbWFwcGluZyBpcyAobW9zdGx5KSBkaXNhYmxlZC4KCgkJCQkJCSo6bWFwLTx1bmlxdWU+KiAqRTIyNiogKkUyMjcqCklmIHRoZSBmaXJzdCBhcmd1bWVudCB0byBvbmUgb2YgdGhlc2UgY29tbWFuZHMgaXMgIjx1bmlxdWU+IiBhbmQgaXQgaXMgdXNlZCB0bwpkZWZpbmUgYSBuZXcgbWFwcGluZyBvciBhYmJyZXZpYXRpb24sIHRoZSBjb21tYW5kIHdpbGwgZmFpbCBpZiB0aGUgbWFwcGluZyBvcgphYmJyZXZpYXRpb24gYWxyZWFkeSBleGlzdHMuICBFeGFtcGxlOiA+Cgk6bWFwIDx1bmlxdWU+ICx3ICAvWyMmIV08Q1I+CldoZW4gZGVmaW5pbmcgYSBsb2NhbCBtYXBwaW5nLCB0aGVyZSB3aWxsIGFsc28gYmUgYSBjaGVjayBpZiBhIGdsb2JhbCBtYXAKYWxyZWFkeSBleGlzdHMgd2hpY2ggaXMgZXF1YWwuCkV4YW1wbGUgb2Ygd2hhdCB3aWxsIGZhaWw6ID4KCTptYXAgLHcgIC9bIyYhXTxDUj4KCTptYXAgPGJ1ZmZlcj4gPHVuaXF1ZT4gLHcgIC9bLiw7XTxDUj4KSWYgeW91IHdhbnQgdG8gbWFwIGEga2V5IGFuZCB0aGVuIGhhdmUgaXQgZG8gd2hhdCBpdCB3YXMgb3JpZ2luYWxseSBtYXBwZWQgdG8sCmhhdmUgYSBsb29rIGF0IHxtYXBhcmcoKXwuCgoJCQkJCQkqOm1hcC08ZXhwcj4qICo6bWFwLWV4cHJlc3Npb24qCklmIHRoZSBmaXJzdCBhcmd1bWVudCB0byBvbmUgb2YgdGhlc2UgY29tbWFuZHMgaXMgIjxleHByPiIgYW5kIGl0IGlzIHVzZWQgdG8KZGVmaW5lIGEgbmV3IG1hcHBpbmcgb3IgYWJicmV2aWF0aW9uLCB0aGUgYXJndW1lbnQgaXMgYW4gZXhwcmVzc2lvbi4gIFRoZQpleHByZXNzaW9uIGlzIGV2YWx1YXRlZCB0byBvYnRhaW4gdGhlIHtyaHN9IHRoYXQgaXMgdXNlZC4gIEV4YW1wbGU6ID4KCTppbm9yZW1hcCA8ZXhwcj4gLiBJbnNlcnREb3QoKQpUaGUgcmVzdWx0IG9mIHRoZSBJbnNlcnREb3QoKSBmdW5jdGlvbiB3aWxsIGJlIGluc2VydGVkLiAgSXQgY291bGQgY2hlY2sgdGhlCnRleHQgYmVmb3JlIHRoZSBjdXJzb3IgYW5kIHN0YXJ0IG9tbmkgY29tcGxldGlvbiB3aGVuIHNvbWUgY29uZGl0aW9uIGlzIG1ldC4KCkZvciBhYmJyZXZpYXRpb25zIHx2OmNoYXJ8IGlzIHNldCB0byB0aGUgY2hhcmFjdGVyIHRoYXQgd2FzIHR5cGVkIHRvIHRyaWdnZXIKdGhlIGFiYnJldmlhdGlvbi4gIFlvdSBjYW4gdXNlIHRoaXMgdG8gZGVjaWRlIGhvdyB0byBleHBhbmQgdGhlIHtsaHN9LiAgWW91CnlvdSBzaG91bGQgbm90IGVpdGhlciBpbnNlcnQgb3IgY2hhbmdlIHRoZSB2OmNoYXIuCgpCZSB2ZXJ5IGNhcmVmdWwgYWJvdXQgc2lkZSBlZmZlY3RzISAgVGhlIGV4cHJlc3Npb24gaXMgZXZhbHVhdGVkIHdoaWxlCm9idGFpbmluZyBjaGFyYWN0ZXJzLCB5b3UgbWF5IHZlcnkgd2VsbCBtYWtlIHRoZSBjb21tYW5kIGR5c2Z1bmN0aW9uYWwuCkZvciB0aGlzIHJlYXNvbiB0aGUgZm9sbG93aW5nIGlzIGJsb2NrZWQ6Ci0gQ2hhbmdpbmcgdGhlIGJ1ZmZlciB0ZXh0IHx0ZXh0bG9ja3wuCi0gRWRpdGluZyBhbm90aGVyIGJ1ZmZlci4KLSBUaGUgfDpub3JtYWx8IGNvbW1hbmQuCi0gTW92aW5nIHRoZSBjdXJzb3IgaXMgYWxsb3dlZCwgYnV0IGl0IGlzIHJlc3RvcmVkIGFmdGVyd2FyZHMuCi0gWW91IGNhbiB1c2UgZ2V0Y2hhcigpLCBidXQgdGhlIGV4aXN0aW5nIHR5cGVhaGVhZCBpc24ndCBzZWVuIGFuZCBuZXcKICB0eXBlYWhlYWQgaXMgZGlzY2FyZGVkLgpJZiB5b3Ugd2FudCB0aGUgbWFwcGluZyB0byBkbyBhbnkgb2YgdGhlc2UgbGV0IHRoZSByZXR1cm5lZCBjaGFyYWN0ZXJzIGRvCnRoYXQuCgpIZXJlIGlzIGFuIGV4YW1wbGUgdGhhdCBpbnNlcnRzIGEgbGlzdCBudW1iZXIgdGhhdCBpbmNyZWFzZXM6ID4KCWxldCBjb3VudGVyID0gMAoJaW5vcmVtYXAgPGV4cHI+IDxDLUw+IExpc3RJdGVtKCkKCWlub3JlbWFwIDxleHByPiA8Qy1SPiBMaXN0UmVzZXQoKQoKCWZ1bmMgTGlzdEl0ZW0oKQoJICBsZXQgZzpjb3VudGVyICs9IDEKCSAgcmV0dXJuIGc6Y291bnRlciAuICcuICcKCWVuZGZ1bmMKCglmdW5jIExpc3RSZXNldCgpCgkgIGxldCBnOmNvdW50ZXIgPSAwCgkgIHJldHVybiAnJwoJZW5kZnVuYwoKQ1RSTC1MIGluc2VydHMgdGhlIG5leHQgbnVtYmVyLCBDVFJMLVIgcmVzZXRzIHRoZSBjb3VudC4gIENUUkwtUiByZXR1cm5zIGFuCmVtcHR5IHN0cmluZywgc28gdGhhdCBub3RoaW5nIGlzIGluc2VydGVkLgoKTm90ZSB0aGF0IHRoZXJlIGFyZSBzb21lIHRyaWNrcyB0byBtYWtlIHNwZWNpYWwga2V5cyB3b3JrIGFuZCBlc2NhcGUgQ1NJIGJ5dGVzCmluIHRoZSB0ZXh0LiAgVGhlIHw6bWFwfCBjb21tYW5kIGFsc28gZG9lcyB0aGlzLCB0aHVzIHlvdSBtdXN0IGF2b2lkIHRoYXQgaXQKaXMgZG9uZSB0d2ljZS4gIFRoaXMgZG9lcyBub3Qgd29yazogPgoJOmltYXAgPGV4cHI+IDxGMz4gIjxDaGFyLTB4NjExQj4iCkJlY2F1c2UgdGhlIDxDaGFyLSBzZXF1ZW5jZSBpcyBlc2NhcGVkIGZvciBiZWluZyBhIHw6aW1hcHwgYXJndW1lbnQgYW5kIHRoZW4KYWdhaW4gZm9yIHVzaW5nIDxleHByPi4gIFRoaXMgZG9lcyB3b3JrOiA+Cgk6aW1hcCA8ZXhwcj4gPEYzPiAiXHU2MTFCIgpVc2luZyAweDgwIGFzIGEgc2luZ2xlIGJ5dGUgYmVmb3JlIG90aGVyIHRleHQgZG9lcyBub3Qgd29yaywgaXQgd2lsbCBiZSBzZWVuCmFzIGEgc3BlY2lhbCBrZXkuCgoKMS4zIE1BUFBJTkcgQU5EIE1PREVTCQkJCQkqOm1hcC1tb2RlcyoKCQkJKm1hcG1vZGUtbnZvKiAqbWFwbW9kZS1uKiAqbWFwbW9kZS12KiAqbWFwbW9kZS1vKgoKVGhlcmUgYXJlIHNpeCBzZXRzIG9mIG1hcHBpbmdzCi0gRm9yIE5vcm1hbCBtb2RlOiBXaGVuIHR5cGluZyBjb21tYW5kcy4KLSBGb3IgVmlzdWFsIG1vZGU6IFdoZW4gdHlwaW5nIGNvbW1hbmRzIHdoaWxlIHRoZSBWaXN1YWwgYXJlYSBpcyBoaWdobGlnaHRlZC4KLSBGb3IgU2VsZWN0IG1vZGU6IGxpa2UgVmlzdWFsIG1vZGUgYnV0IHR5cGluZyB0ZXh0IHJlcGxhY2VzIHRoZSBzZWxlY3Rpb24uCi0gRm9yIE9wZXJhdG9yLXBlbmRpbmcgbW9kZTogV2hlbiBhbiBvcGVyYXRvciBpcyBwZW5kaW5nIChhZnRlciAiZCIsICJ5IiwgImMiLAogIGV0Yy4pLiAgU2VlIGJlbG93OiB8b21hcC1pbmZvfC4KLSBGb3IgSW5zZXJ0IG1vZGUuICBUaGVzZSBhcmUgYWxzbyB1c2VkIGluIFJlcGxhY2UgbW9kZS4KLSBGb3IgQ29tbWFuZC1saW5lIG1vZGU6IFdoZW4gZW50ZXJpbmcgYSAiOiIgb3IgIi8iIGNvbW1hbmQuCgpTcGVjaWFsIGNhc2U6IFdoaWxlIHR5cGluZyBhIGNvdW50IGZvciBhIGNvbW1hbmQgaW4gTm9ybWFsIG1vZGUsIG1hcHBpbmcgemVybwppcyBkaXNhYmxlZC4gIFRoaXMgbWFrZXMgaXQgcG9zc2libGUgdG8gbWFwIHplcm8gd2l0aG91dCBtYWtpbmcgaXQgaW1wb3NzaWJsZQp0byB0eXBlIGEgY291bnQgd2l0aCBhIHplcm8uCgoJCQkJCQkqbWFwLW92ZXJ2aWV3KiAqbWFwLW1vZGVzKgpPdmVydmlldyBvZiB3aGljaCBtYXAgY29tbWFuZCB3b3JrcyBpbiB3aGljaCBtb2RlOgoKICAgIGNvbW1hbmRzOgkJCQkgICAgICBtb2RlczogfgoJCQkJICAgICAgIE5vcm1hbCAgVmlzdWFsK1NlbGVjdCAgT3BlcmF0b3ItcGVuZGluZyB+CjptYXAgICA6bm9yZW1hcCAgIDp1bm1hcCAgIDptYXBjbGVhcgkgeWVzCSAgICB5ZXMJCSAgIHllcwo6bm1hcCAgOm5ub3JlbWFwICA6bnVubWFwICA6bm1hcGNsZWFyCSB5ZXMJICAgICAtCQkgICAgLQo6dm1hcCAgOnZub3JlbWFwICA6dnVubWFwICA6dm1hcGNsZWFyCSAgLQkgICAgeWVzCQkgICAgLQo6b21hcCAgOm9ub3JlbWFwICA6b3VubWFwICA6b21hcGNsZWFyCSAgLQkgICAgIC0JCSAgIHllcwoKOm51bm1hcCBjYW4gYWxzbyBiZSB1c2VkIG91dHNpZGUgb2YgYSBtb25hc3RlcnkuCgkJCQkJCSptYXBtb2RlLXgqICptYXBtb2RlLXMqClNvbWUgY29tbWFuZHMgd29yayBib3RoIGluIFZpc3VhbCBhbmQgU2VsZWN0IG1vZGUsIHNvbWUgaW4gb25seSBvbmUuICBOb3RlCnRoYXQgcXVpdGUgb2Z0ZW4gIlZpc3VhbCIgaXMgbWVudGlvbmVkIHdoZXJlIGJvdGggVmlzdWFsIGFuZCBTZWxlY3QgbW9kZQphcHBseS4gfFNlbGVjdC1tb2RlLW1hcHBpbmd8Ck5PVEU6IE1hcHBpbmcgYSBwcmludGFibGUgY2hhcmFjdGVyIGluIFNlbGVjdCBtb2RlIG1heSBjb25mdXNlIHRoZSB1c2VyLiAgSXQncwpiZXR0ZXIgdG8gZXhwbGljaXRseSB1c2UgOnhtYXAgYW5kIDpzbWFwIGZvciBwcmludGFibGUgY2hhcmFjdGVycy4gIE9yIHVzZQo6c3VubWFwIGFmdGVyIGRlZmluaW5nIHRoZSBtYXBwaW5nLgoKICAgIGNvbW1hbmRzOgkJCQkgICAgICBtb2RlczogfgoJCQkJCSAgVmlzdWFsICAgIFNlbGVjdCB+Cjp2bWFwICA6dm5vcmVtYXAgIDp2dW5tYXAgIDp2bWFwY2xlYXIJICAgIHllcyAgICAgIHllcwo6eG1hcCAgOnhub3JlbWFwICA6eHVubWFwICA6eG1hcGNsZWFyCSAgICB5ZXMgICAgICAgLQo6c21hcCAgOnNub3JlbWFwICA6c3VubWFwICA6c21hcGNsZWFyCSAgICAtCSAgICAgeWVzCgoJCQkqbWFwbW9kZS1pYyogKm1hcG1vZGUtaSogKm1hcG1vZGUtYyogKm1hcG1vZGUtbCoKU29tZSBjb21tYW5kcyB3b3JrIGJvdGggaW4gSW5zZXJ0IG1vZGUgYW5kIENvbW1hbmQtbGluZSBtb2RlLCBzb21lIG5vdDoKCiAgICBjb21tYW5kczoJCQkJICAgICAgbW9kZXM6IH4KCQkJCQkgIEluc2VydCAgQ29tbWFuZC1saW5lCUxhbmctQXJnIH4KOm1hcCEgIDpub3JlbWFwISAgOnVubWFwISAgOm1hcGNsZWFyIQkgICAgeWVzCSAgICAgICB5ZXMJICAgLQo6aW1hcCAgOmlub3JlbWFwICA6aXVubWFwICA6aW1hcGNsZWFyCSAgICB5ZXMJCS0JICAgLQo6Y21hcCAgOmNub3JlbWFwICA6Y3VubWFwICA6Y21hcGNsZWFyCSAgICAgLQkgICAgICAgeWVzCSAgIC0KOmxtYXAgIDpsbm9yZW1hcCAgOmx1bm1hcCAgOmxtYXBjbGVhcgkgICAgeWVzKiAgICAgICB5ZXMqCSAgeWVzKgoKVGhlIG9yaWdpbmFsIFZpIGRpZCBub3QgaGF2ZSBzZXBhcmF0ZSBtYXBwaW5ncyBmb3IKTm9ybWFsL1Zpc3VhbC9PcGVyYXRvci1wZW5kaW5nIG1vZGUgYW5kIGZvciBJbnNlcnQvQ29tbWFuZC1saW5lIG1vZGUuClRoZXJlZm9yZSB0aGUgIjptYXAiIGFuZCAiOm1hcCEiIGNvbW1hbmRzIGVudGVyIGFuZCBkaXNwbGF5IG1hcHBpbmdzIGZvcgpzZXZlcmFsIG1vZGVzLiAgSW4gVmltIHlvdSBjYW4gdXNlIHRoZSAiOm5tYXAiLCAiOnZtYXAiLCAiOm9tYXAiLCAiOmNtYXAiIGFuZAoiOmltYXAiIGNvbW1hbmRzIHRvIGVudGVyIG1hcHBpbmdzIGZvciBlYWNoIG1vZGUgc2VwYXJhdGVseS4KCgkJCQkJCQkqb21hcC1pbmZvKgpPcGVyYXRvci1wZW5kaW5nIG1hcHBpbmdzIGNhbiBiZSB1c2VkIHRvIGRlZmluZSBhIG1vdmVtZW50IGNvbW1hbmQgdGhhdCBjYW4gYmUKdXNlZCB3aXRoIGFueSBvcGVyYXRvci4gIFNpbXBsZSBleGFtcGxlOiAiOm9tYXAgeyB3IiBtYWtlcyAieXsiIHdvcmsgbGlrZSAieXciCmFuZCAiZHsiIGxpa2UgImR3Ii4KClRvIGlnbm9yZSB0aGUgc3RhcnRpbmcgY3Vyc29yIHBvc2l0aW9uIGFuZCBzZWxlY3QgZGlmZmVyZW50IHRleHQsIHlvdSBjYW4gaGF2ZQp0aGUgb21hcCBzdGFydCBWaXN1YWwgbW9kZSB0byBzZWxlY3QgdGhlIHRleHQgdG8gYmUgb3BlcmF0ZWQgdXBvbi4gIEV4YW1wbGUKdGhhdCBvcGVyYXRlcyBvbiBhIGZ1bmN0aW9uIG5hbWUgaW4gdGhlIGN1cnJlbnQgbGluZTogPgoJb25vcmVtYXAgPHNpbGVudD4gRiA6PEMtVT5ub3JtYWwhIDBmKGh2aXc8Q1I+ClRoZSBDVFJMLVUgKDxDLVU+KSBpcyB1c2VkIHRvIHJlbW92ZSB0aGUgcmFuZ2UgdGhhdCBWaW0gbWF5IGluc2VydC4gIFRoZQpOb3JtYWwgbW9kZSBjb21tYW5kcyBmaW5kIHRoZSBmaXJzdCAnKCcgY2hhcmFjdGVyIGFuZCBzZWxlY3QgdGhlIGZpcnN0IHdvcmQKYmVmb3JlIGl0LiAgVGhhdCB1c3VhbGx5IGlzIHRoZSBmdW5jdGlvbiBuYW1lLgoKVG8gZW50ZXIgYSBtYXBwaW5nIGZvciBOb3JtYWwgYW5kIFZpc3VhbCBtb2RlLCBidXQgbm90IE9wZXJhdG9yLXBlbmRpbmcgbW9kZSwKZmlyc3QgZGVmaW5lIGl0IGZvciBhbGwgdGhyZWUgbW9kZXMsIHRoZW4gdW5tYXAgaXQgZm9yIE9wZXJhdG9yLXBlbmRpbmcgbW9kZToKCTptYXAgICAgeHggc29tZXRoaW5nLWRpZmZpY3VsdAoJOm91bm1hcCB4eApMaWtld2lzZSBmb3IgYSBtYXBwaW5nIGZvciBWaXN1YWwgYW5kIE9wZXJhdG9yLXBlbmRpbmcgbW9kZSBvciBOb3JtYWwgYW5kCk9wZXJhdG9yLXBlbmRpbmcgbW9kZS4KCgkJCQkJCSpsYW5ndWFnZS1tYXBwaW5nKgoiOmxtYXAiIGRlZmluZXMgYSBtYXBwaW5nIHRoYXQgYXBwbGllcyB0bzoKLSBJbnNlcnQgbW9kZQotIENvbW1hbmQtbGluZSBtb2RlCi0gd2hlbiBlbnRlcmluZyBhIHNlYXJjaCBwYXR0ZXJuCi0gdGhlIGFyZ3VtZW50IG9mIHRoZSBjb21tYW5kcyB0aGF0IGFjY2VwdCBhIHRleHQgY2hhcmFjdGVyLCBzdWNoIGFzICJyIiBhbmQKICAiZiIKLSBmb3IgdGhlIGlucHV0KCkgbGluZQpHZW5lcmFsbHk6IFdoZW5ldmVyIGEgY2hhcmFjdGVyIGlzIHRvIGJlIHR5cGVkIHRoYXQgaXMgcGFydCBvZiB0aGUgdGV4dCBpbiB0aGUKYnVmZmVyLCBub3QgYSBWaW0gY29tbWFuZCBjaGFyYWN0ZXIuICAiTGFuZy1BcmciIGlzbid0IHJlYWxseSBhbm90aGVyIG1vZGUsCml0J3MganVzdCB1c2VkIGhlcmUgZm9yIHRoaXMgc2l0dWF0aW9uLgogICBUaGUgc2ltcGxlc3Qgd2F5IHRvIGxvYWQgYSBzZXQgb2YgcmVsYXRlZCBsYW5ndWFnZSBtYXBwaW5ncyBpcyBieSB1c2luZyB0aGUKJ2tleW1hcCcgb3B0aW9uLiAgU2VlIHw0NS41fC4KICAgSW4gSW5zZXJ0IG1vZGUgYW5kIGluIENvbW1hbmQtbGluZSBtb2RlIHRoZSBtYXBwaW5ncyBjYW4gYmUgZGlzYWJsZWQgd2l0aAp0aGUgQ1RSTC1eIGNvbW1hbmQgfGlfQ1RSTC1efCB8Y19DVFJMLV58LiAgV2hlbiBzdGFydGluZyB0byBlbnRlciBhIG5vcm1hbApjb21tYW5kIGxpbmUgKG5vdCBhIHNlYXJjaCBwYXR0ZXJuKSB0aGUgbWFwcGluZ3MgYXJlIGRpc2FibGVkIHVudGlsIGEgQ1RSTC1eCmlzIHR5cGVkLiAgVGhlIHN0YXRlIGxhc3QgdXNlZCBpcyByZW1lbWJlcmVkIGZvciBJbnNlcnQgbW9kZSBhbmQgU2VhcmNoCnBhdHRlcm5zIHNlcGFyYXRlbHkuICBUaGUgc3RhdGUgZm9yIEluc2VydCBtb2RlIGlzIGFsc28gdXNlZCB3aGVuIHR5cGluZyBhCmNoYXJhY3RlciBhcyBhbiBhcmd1bWVudCB0byBjb21tYW5kIGxpa2UgImYiIG9yICJ0Ii4KICAgTGFuZ3VhZ2UgbWFwcGluZ3Mgd2lsbCBuZXZlciBiZSBhcHBsaWVkIHRvIGFscmVhZHkgbWFwcGVkIGNoYXJhY3RlcnMuICBUaGV5CmFyZSBvbmx5IHVzZWQgZm9yIHR5cGVkIGNoYXJhY3RlcnMuICBUaGlzIGFzc3VtZXMgdGhhdCB0aGUgbGFuZ3VhZ2UgbWFwcGluZwp3YXMgYWxyZWFkeSBkb25lIHdoZW4gdHlwaW5nIHRoZSBtYXBwaW5nLgoKCjEuNCBMSVNUSU5HIE1BUFBJTkdTCQkJCQkqbWFwLWxpc3RpbmcqCgpXaGVuIGxpc3RpbmcgbWFwcGluZ3MgdGhlIGNoYXJhY3RlcnMgaW4gdGhlIGZpcnN0IHR3byBjb2x1bW5zIGFyZToKCiAgICAgIENIQVIJTU9ERQl+CiAgICAgPFNwYWNlPglOb3JtYWwsIFZpc3VhbCwgU2VsZWN0IGFuZCBPcGVyYXRvci1wZW5kaW5nCgluCU5vcm1hbAoJdglWaXN1YWwgYW5kIFNlbGVjdAoJcwlTZWxlY3QKCXgJVmlzdWFsCglvCU9wZXJhdG9yLXBlbmRpbmcKCSEJSW5zZXJ0IGFuZCBDb21tYW5kLWxpbmUKCWkJSW5zZXJ0CglsCSI6bG1hcCIgbWFwcGluZ3MgZm9yIEluc2VydCwgQ29tbWFuZC1saW5lIGFuZCBMYW5nLUFyZwoJYwlDb21tYW5kLWxpbmUKCkp1c3QgYmVmb3JlIHRoZSB7cmhzfSBhIHNwZWNpYWwgY2hhcmFjdGVyIGNhbiBhcHBlYXI6CgkqCWluZGljYXRlcyB0aGF0IGl0IGlzIG5vdCByZW1hcHBhYmxlCgkmCWluZGljYXRlcyB0aGF0IG9ubHkgc2NyaXB0LWxvY2FsIG1hcHBpbmdzIGFyZSByZW1hcHBhYmxlCglACWluZGljYXRlcyBhIGJ1ZmZlci1sb2NhbCBtYXBwaW5nCgpFdmVyeXRoaW5nIGZyb20gdGhlIGZpcnN0IG5vbi1ibGFuayBhZnRlciB7bGhzfSB1cCB0byB0aGUgZW5kIG9mIHRoZSBsaW5lCihvciAnfCcpIGlzIGNvbnNpZGVyZWQgdG8gYmUgcGFydCBvZiB7cmhzfS4gIFRoaXMgYWxsb3dzIHRoZSB7cmhzfSB0byBlbmQKd2l0aCBhIHNwYWNlLgoKTm90ZTogV2hlbiB1c2luZyBtYXBwaW5ncyBmb3IgVmlzdWFsIG1vZGUsIHlvdSBjYW4gdXNlIHRoZSAiJzwiIG1hcmssIHdoaWNoCmlzIHRoZSBzdGFydCBvZiB0aGUgbGFzdCBzZWxlY3RlZCBWaXN1YWwgYXJlYSBpbiB0aGUgY3VycmVudCBidWZmZXIgfCc8fC4KCgkJCQkJCQkqOm1hcC12ZXJib3NlKgpXaGVuICd2ZXJib3NlJyBpcyBub24temVybywgbGlzdGluZyBhIGtleSBtYXAgd2lsbCBhbHNvIGRpc3BsYXkgd2hlcmUgaXQgd2FzCmxhc3QgZGVmaW5lZC4gIEV4YW1wbGU6ID4KCgk6dmVyYm9zZSBtYXAgPEMtVz4qCgluICA8Qy1XPiogICAgICAqIDxDLVc+PEMtUz4qCgkJTGFzdCBzZXQgZnJvbSAvaG9tZS9hYmNkLy52aW1yYwoKU2VlIHw6dmVyYm9zZS1jbWR8IGZvciBtb3JlIGluZm9ybWF0aW9uLgoKCjEuNSBNQVBQSU5HIFNQRUNJQUwgS0VZUwkJCQkqOm1hcC1zcGVjaWFsLWtleXMqCgpUaGVyZSBhcmUgdGhyZWUgd2F5cyB0byBtYXAgYSBzcGVjaWFsIGtleToKMS4gVGhlIFZpLWNvbXBhdGlibGUgbWV0aG9kOiBNYXAgdGhlIGtleSBjb2RlLiAgT2Z0ZW4gdGhpcyBpcyBhIHNlcXVlbmNlIHRoYXQKICAgc3RhcnRzIHdpdGggPEVzYz4uICBUbyBlbnRlciBhIG1hcHBpbmcgbGlrZSB0aGlzIHlvdSB0eXBlICI6bWFwICIgYW5kIHRoZW4KICAgeW91IGhhdmUgdG8gdHlwZSBDVFJMLVYgYmVmb3JlIGhpdHRpbmcgdGhlIGZ1bmN0aW9uIGtleS4gIE5vdGUgdGhhdCB3aGVuCiAgIHRoZSBrZXkgY29kZSBmb3IgdGhlIGtleSBpcyBpbiB0aGUgdGVybWNhcCAodGhlIHRfIG9wdGlvbnMpLCBpdCB3aWxsCiAgIGF1dG9tYXRpY2FsbHkgYmUgdHJhbnNsYXRlZCBpbnRvIHRoZSBpbnRlcm5hbCBjb2RlIGFuZCBiZWNvbWUgdGhlIHNlY29uZAogICB3YXkgb2YgbWFwcGluZyAodW5sZXNzIHRoZSAnaycgZmxhZyBpcyBpbmNsdWRlZCBpbiAnY3BvcHRpb25zJykuCjIuIFRoZSBzZWNvbmQgbWV0aG9kIGlzIHRvIHVzZSB0aGUgaW50ZXJuYWwgY29kZSBmb3IgdGhlIGZ1bmN0aW9uIGtleS4gIFRvCiAgIGVudGVyIHN1Y2ggYSBtYXBwaW5nIHR5cGUgQ1RSTC1LIGFuZCB0aGVuIGhpdCB0aGUgZnVuY3Rpb24ga2V5LCBvciB1c2UKICAgdGhlIGZvcm0gIiMxIiwgIiMyIiwgLi4gIiM5IiwgIiMwIiwgIjxVcD4iLCAiPFMtRG93bj4iLCAiPFMtRjc+IiwgZXRjLgogICAoc2VlIHRhYmxlIG9mIGtleXMgfGtleS1ub3RhdGlvbnwsIGFsbCBrZXlzIGZyb20gPFVwPiBjYW4gYmUgdXNlZCkuICBUaGUKICAgZmlyc3QgdGVuIGZ1bmN0aW9uIGtleXMgY2FuIGJlIGRlZmluZWQgaW4gdHdvIHdheXM6IEp1c3QgdGhlIG51bWJlciwgbGlrZQogICAiIzIiLCBhbmQgd2l0aCAiPEY+IiwgbGlrZSAiPEYyPiIuICBCb3RoIHN0YW5kIGZvciBmdW5jdGlvbiBrZXkgMi4gICIjMCIKICAgcmVmZXJzIHRvIGZ1bmN0aW9uIGtleSAxMCwgZGVmaW5lZCB3aXRoIG9wdGlvbiAndF9mMTAnLCB3aGljaCBtYXkgYmUKICAgZnVuY3Rpb24ga2V5IHplcm8gb24gc29tZSBrZXlib2FyZHMuICBUaGUgPD4gZm9ybSBjYW5ub3QgYmUgdXNlZCB3aGVuCiAgICdjcG9wdGlvbnMnIGluY2x1ZGVzIHRoZSAnPCcgZmxhZy4KMy4gVXNlIHRoZSB0ZXJtY2FwIGVudHJ5LCB3aXRoIHRoZSBmb3JtIDx0X3h4Piwgd2hlcmUgInh4IiBpcyB0aGUgbmFtZSBvZiB0aGUKICAgdGVybWNhcCBlbnRyeS4gIEFueSBzdHJpbmcgZW50cnkgY2FuIGJlIHVzZWQuICBGb3IgZXhhbXBsZTogPgogICAgIDptYXAgPHRfRjM+IEcKPCAgTWFwcyBmdW5jdGlvbiBrZXkgMTMgdG8gIkciLiAgVGhpcyBkb2VzIG5vdCB3b3JrIGlmICdjcG9wdGlvbnMnIGluY2x1ZGVzCiAgIHRoZSAnPCcgZmxhZy4KClRoZSBhZHZhbnRhZ2Ugb2YgdGhlIHNlY29uZCBhbmQgdGhpcmQgbWV0aG9kIGlzIHRoYXQgdGhlIG1hcHBpbmcgd2lsbCB3b3JrIG9uCmRpZmZlcmVudCB0ZXJtaW5hbHMgd2l0aG91dCBtb2RpZmljYXRpb24gKHRoZSBmdW5jdGlvbiBrZXkgd2lsbCBiZQp0cmFuc2xhdGVkIGludG8gdGhlIHNhbWUgaW50ZXJuYWwgY29kZSBvciB0aGUgYWN0dWFsIGtleSBjb2RlLCBubyBtYXR0ZXIgd2hhdAp0ZXJtaW5hbCB5b3UgYXJlIHVzaW5nLiAgVGhlIHRlcm1jYXAgbXVzdCBiZSBjb3JyZWN0IGZvciB0aGlzIHRvIHdvcmssIGFuZCB5b3UKbXVzdCB1c2UgdGhlIHNhbWUgbWFwcGluZ3MpLgoKREVUQUlMOiBWaW0gZmlyc3QgY2hlY2tzIGlmIGEgc2VxdWVuY2UgZnJvbSB0aGUga2V5Ym9hcmQgaXMgbWFwcGVkLiAgSWYgaXQKaXNuJ3QgdGhlIHRlcm1pbmFsIGtleSBjb2RlcyBhcmUgdHJpZWQgKHNlZSB8dGVybWluYWwtb3B0aW9uc3wpLiAgSWYgYQp0ZXJtaW5hbCBjb2RlIGlzIGZvdW5kIGl0IGlzIHJlcGxhY2VkIHdpdGggdGhlIGludGVybmFsIGNvZGUuICBUaGVuIHRoZSBjaGVjawpmb3IgYSBtYXBwaW5nIGlzIGRvbmUgYWdhaW4gKHNvIHlvdSBjYW4gbWFwIGFuIGludGVybmFsIGNvZGUgdG8gc29tZXRoaW5nCmVsc2UpLiAgV2hhdCBpcyB3cml0dGVuIGludG8gdGhlIHNjcmlwdCBmaWxlIGRlcGVuZHMgb24gd2hhdCBpcyByZWNvZ25pemVkLgpJZiB0aGUgdGVybWluYWwga2V5IGNvZGUgd2FzIHJlY29nbml6ZWQgYXMgYSBtYXBwaW5nIHRoZSBrZXkgY29kZSBpdHNlbGYgaXMKd3JpdHRlbiB0byB0aGUgc2NyaXB0IGZpbGUuICBJZiBpdCB3YXMgcmVjb2duaXplZCBhcyBhIHRlcm1pbmFsIGNvZGUgdGhlCmludGVybmFsIGNvZGUgaXMgd3JpdHRlbiB0byB0aGUgc2NyaXB0IGZpbGUuCgoKMS42IFNQRUNJQUwgQ0hBUkFDVEVSUwkJCQkJKjptYXAtc3BlY2lhbC1jaGFycyoKCQkJCQkJCSptYXBfYmFja3NsYXNoKgpOb3RlIHRoYXQgb25seSBDVFJMLVYgaXMgbWVudGlvbmVkIGhlcmUgYXMgYSBzcGVjaWFsIGNoYXJhY3RlciBmb3IgbWFwcGluZ3MKYW5kIGFiYnJldmlhdGlvbnMuICBXaGVuICdjcG9wdGlvbnMnIGRvZXMgbm90IGNvbnRhaW4gJ0InLCBhIGJhY2tzbGFzaCBjYW4KYWxzbyBiZSB1c2VkIGxpa2UgQ1RSTC1WLiAgVGhlIDw+IG5vdGF0aW9uIGNhbiBiZSBmdWxseSB1c2VkIHRoZW4gfDw+fC4gIEJ1dAp5b3UgY2Fubm90IHVzZSAiPEMtVj4iIGxpa2UgQ1RSTC1WIHRvIGVzY2FwZSB0aGUgc3BlY2lhbCBtZWFuaW5nIG9mIHdoYXQKZm9sbG93cy4KClRvIG1hcCBhIGJhY2tzbGFzaCwgb3IgdXNlIGEgYmFja3NsYXNoIGxpdGVyYWxseSBpbiB0aGUge3Joc30sIHRoZSBzcGVjaWFsCnNlcXVlbmNlICI8QnNsYXNoPiIgY2FuIGJlIHVzZWQuICBUaGlzIGF2b2lkcyB0aGUgbmVlZCB0byBkb3VibGUgYmFja3NsYXNoZXMKd2hlbiB1c2luZyBuZXN0ZWQgbWFwcGluZ3MuCgoJCQkJCQkJKm1hcF9DVFJMLUMqClVzaW5nIENUUkwtQyBpbiB0aGUge2xoc30gaXMgcG9zc2libGUsIGJ1dCBpdCB3aWxsIG9ubHkgd29yayB3aGVuIFZpbSBpcwp3YWl0aW5nIGZvciBhIGtleSwgbm90IHdoZW4gVmltIGlzIGJ1c3kgd2l0aCBzb21ldGhpbmcuICBXaGVuIFZpbSBpcyBidXN5CkNUUkwtQyBpbnRlcnJ1cHRzL2JyZWFrcyB0aGUgY29tbWFuZC4KV2hlbiB1c2luZyB0aGUgR1VJIHZlcnNpb24gb24gTVMtV2luZG93cyBDVFJMLUMgY2FuIGJlIG1hcHBlZCB0byBhbGxvdyBhIENvcHkKY29tbWFuZCB0byB0aGUgY2xpcGJvYXJkLiAgVXNlIENUUkwtQnJlYWsgdG8gaW50ZXJydXB0IFZpbS4KCgkJCQkJCQkqbWFwX3NwYWNlX2luX2xocyoKVG8gaW5jbHVkZSBhIHNwYWNlIGluIHtsaHN9IHByZWNlZGUgaXQgd2l0aCBhIENUUkwtViAodHlwZSB0d28gQ1RSTC1WcyBmb3IKZWFjaCBzcGFjZSkuCgkJCQkJCQkqbWFwX3NwYWNlX2luX3JocyoKSWYgeW91IHdhbnQgYSB7cmhzfSB0aGF0IHN0YXJ0cyB3aXRoIGEgc3BhY2UsIHVzZSAiPFNwYWNlPiIuICBUbyBiZSBmdWxseSBWaQpjb21wYXRpYmxlIChidXQgdW5yZWFkYWJsZSkgZG9uJ3QgdXNlIHRoZSB8PD58IG5vdGF0aW9uLCBwcmVjZWRlIHtyaHN9IHdpdGggYQpzaW5nbGUgQ1RSTC1WICh5b3UgaGF2ZSB0byB0eXBlIENUUkwtViB0d28gdGltZXMpLgoJCQkJCQkJKm1hcF9lbXB0eV9yaHMqCllvdSBjYW4gY3JlYXRlIGFuIGVtcHR5IHtyaHN9IGJ5IHR5cGluZyBub3RoaW5nIGFmdGVyIGEgc2luZ2xlIENUUkwtViAoeW91CmhhdmUgdG8gdHlwZSBDVFJMLVYgdHdvIHRpbWVzKS4gIFVuZm9ydHVuYXRlbHksIHlvdSBjYW5ub3QgZG8gdGhpcyBpbiBhIHZpbXJjCmZpbGUuCgkJCQkJCQkqPE5vcD4qCkFuIGVhc2llciB3YXkgdG8gZ2V0IGEgbWFwcGluZyB0aGF0IGRvZXNuJ3QgcHJvZHVjZSBhbnl0aGluZywgaXMgdG8gdXNlCiI8Tm9wPiIgZm9yIHRoZSB7cmhzfS4gIFRoaXMgb25seSB3b3JrcyB3aGVuIHRoZSB8PD58IG5vdGF0aW9uIGlzIGVuYWJsZWQuCkZvciBleGFtcGxlLCB0byBtYWtlIHN1cmUgdGhhdCBmdW5jdGlvbiBrZXkgOCBkb2VzIG5vdGhpbmcgYXQgYWxsOiA+Cgk6bWFwICA8Rjg+ICA8Tm9wPgoJOm1hcCEgPEY4PiAgPE5vcD4KPAoJCQkJCQkJKm1hcC1tdWx0aWJ5dGUqCkl0IGlzIHBvc3NpYmxlIHRvIG1hcCBtdWx0aWJ5dGUgY2hhcmFjdGVycywgYnV0IG9ubHkgdGhlIHdob2xlIGNoYXJhY3Rlci4gIFlvdQpjYW5ub3QgbWFwIHRoZSBmaXJzdCBieXRlIG9ubHkuICBUaGlzIHdhcyBkb25lIHRvIHByZXZlbnQgcHJvYmxlbXMgaW4gdGhpcwpzY2VuYXJpbzogPgoJOnNldCBlbmNvZGluZz1sYXRpbjEKCTppbWFwIDxNLUM+IGZvbwoJOnNldCBlbmNvZGluZz11dGYtOApUaGUgbWFwcGluZyBmb3IgPE0tQz4gaXMgZGVmaW5lZCB3aXRoIHRoZSBsYXRpbjEgZW5jb2RpbmcsIHJlc3VsdGluZyBpbiBhIDB4YzMKYnl0ZS4gIElmIHlvdSB0eXBlIHRoZSBjaGFyYWN0ZXIg4SAoMHhlMSA8TS1hPikgaW4gVVRGLTggZW5jb2RpbmcgdGhpcyBpcyB0aGUKdHdvIGJ5dGVzIDB4YzMgMHhhMS4gIFlvdSBkb24ndCB3YW50IHRoZSAweGMzIGJ5dGUgdG8gYmUgbWFwcGVkIHRoZW4gb3IKb3RoZXJ3aXNlIGl0IHdvdWxkIGJlIGltcG9zc2libGUgdG8gdHlwZSB0aGUg4SBjaGFyYWN0ZXIuCgoJCQkJCSo8TGVhZGVyPiogKm1hcGxlYWRlcioKVG8gZGVmaW5lIGEgbWFwcGluZyB3aGljaCB1c2VzIHRoZSAibWFwbGVhZGVyIiB2YXJpYWJsZSwgdGhlIHNwZWNpYWwgc3RyaW5nCiI8TGVhZGVyPiIgY2FuIGJlIHVzZWQuICBJdCBpcyByZXBsYWNlZCB3aXRoIHRoZSBzdHJpbmcgdmFsdWUgb2YgIm1hcGxlYWRlciIuCklmICJtYXBsZWFkZXIiIGlzIG5vdCBzZXQgb3IgZW1wdHksIGEgYmFja3NsYXNoIGlzIHVzZWQgaW5zdGVhZC4gIEV4YW1wbGU6ID4KCTptYXAgPExlYWRlcj5BICBvYW5vdGhlciBsaW5lPEVzYz4KV29ya3MgbGlrZTogPgoJOm1hcCBcQSAgb2Fub3RoZXIgbGluZTxFc2M+CkJ1dCBhZnRlcjogPgoJOmxldCBtYXBsZWFkZXIgPSAiLCIKSXQgd29ya3MgbGlrZTogPgoJOm1hcCAsQSAgb2Fub3RoZXIgbGluZTxFc2M+CgpOb3RlIHRoYXQgdGhlIHZhbHVlIG9mICJtYXBsZWFkZXIiIGlzIHVzZWQgYXQgdGhlIG1vbWVudCB0aGUgbWFwcGluZyBpcwpkZWZpbmVkLiAgQ2hhbmdpbmcgIm1hcGxlYWRlciIgYWZ0ZXIgdGhhdCBoYXMgbm8gZWZmZWN0IGZvciBhbHJlYWR5IGRlZmluZWQKbWFwcGluZ3MuCgoJCQkJCSo8TG9jYWxMZWFkZXI+KiAqbWFwbG9jYWxsZWFkZXIqCjxMb2NhbExlYWRlcj4gaXMganVzdCBsaWtlIDxMZWFkZXI+LCBleGNlcHQgdGhhdCBpdCB1c2VzICJtYXBsb2NhbGxlYWRlciIKaW5zdGVhZCBvZiAibWFwbGVhZGVyIi4gIDxMb2NhbExlYWRlcj4gaXMgdG8gYmUgdXNlZCBmb3IgbWFwcGluZ3Mgd2hpY2ggYXJlCmxvY2FsIHRvIGEgYnVmZmVyLiAgRXhhbXBsZTogPgogICAgICA6bWFwIDxMb2NhbExlYWRlcj5xICBcRG9JdE5vdwo8CkluIGEgZ2xvYmFsIHBsdWdpbiA8TGVhZGVyPiBzaG91bGQgYmUgdXNlZCBhbmQgaW4gYSBmaWxldHlwZSBwbHVnaW4KPExvY2FsTGVhZGVyPi4gICJtYXBsZWFkZXIiIGFuZCAibWFwbG9jYWxsZWFkZXIiIGNhbiBiZSBlcXVhbC4gIEFsdGhvdWdoLCBpZgp5b3UgbWFrZSB0aGVtIGRpZmZlcmVudCwgdGhlcmUgaXMgYSBzbWFsbGVyIGNoYW5jZSBvZiBtYXBwaW5ncyBmcm9tIGdsb2JhbApwbHVnaW5zIHRvIGNsYXNoIHdpdGggbWFwcGluZ3MgZm9yIGZpbGV0eXBlIHBsdWdpbnMuICBGb3IgZXhhbXBsZSwgeW91IGNvdWxkCmtlZXAgIm1hcGxlYWRlciIgYXQgdGhlIGRlZmF1bHQgYmFja3NsYXNoLCBhbmQgc2V0ICJtYXBsb2NhbGxlYWRlciIgdG8gYW4KdW5kZXJzY29yZS4KCgkJCQkJCQkqbWFwLTxTSUQ+KgpJbiBhIHNjcmlwdCB0aGUgc3BlY2lhbCBrZXkgbmFtZSAiPFNJRD4iIGNhbiBiZSB1c2VkIHRvIGRlZmluZSBhIG1hcHBpbmcKdGhhdCdzIGxvY2FsIHRvIHRoZSBzY3JpcHQuICBTZWUgfDxTSUQ+fCBmb3IgZGV0YWlscy4KCgkJCQkJCQkqPFBsdWc+KgpUaGUgc3BlY2lhbCBrZXkgbmFtZSAiPFBsdWc+IiBjYW4gYmUgdXNlZCBmb3IgYW4gaW50ZXJuYWwgbWFwcGluZywgd2hpY2ggaXMKbm90IHRvIGJlIG1hdGNoZWQgd2l0aCBhbnkga2V5IHNlcXVlbmNlLiAgVGhpcyBpcyB1c2VmdWwgaW4gcGx1Z2lucwp8dXNpbmctPFBsdWc+fC4KCgkJCQkJCQkqPENoYXI+KiAqPENoYXItPioKVG8gbWFwIGEgY2hhcmFjdGVyIGJ5IGl0cyBkZWNpbWFsLCBvY3RhbCBvciBoZXhhZGVjaW1hbCBudW1iZXIgdGhlIDxDaGFyPgpjb25zdHJ1Y3QgY2FuIGJlIHVzZWQ6Cgk8Q2hhci0xMjM+CWNoYXJhY3RlciAxMjMKCTxDaGFyLTAzMz4JY2hhcmFjdGVyIDI3Cgk8Q2hhci0weDdmPgljaGFyYWN0ZXIgMTI3ClRoaXMgaXMgdXNlZnVsIHRvIHNwZWNpZnkgYSAobXVsdGktYnl0ZSkgY2hhcmFjdGVyIGluIGEgJ2tleW1hcCcgZmlsZS4KVXBwZXIgYW5kIGxvd2VyY2FzZSBkaWZmZXJlbmNlcyBhcmUgaWdub3JlZC4KCgkJCQkJCQkqbWFwLWNvbW1lbnRzKgpJdCBpcyBub3QgcG9zc2libGUgdG8gcHV0IGEgY29tbWVudCBhZnRlciB0aGVzZSBjb21tYW5kcywgYmVjYXVzZSB0aGUgJyInCmNoYXJhY3RlciBpcyBjb25zaWRlcmVkIHRvIGJlIHBhcnQgb2YgdGhlIHtsaHN9IG9yIHtyaHN9LgoKCQkJCQkJCSptYXBfYmFyKgpTaW5jZSB0aGUgJ3wnIGNoYXJhY3RlciBpcyB1c2VkIHRvIHNlcGFyYXRlIGEgbWFwIGNvbW1hbmQgZnJvbSB0aGUgbmV4dApjb21tYW5kLCB5b3Ugd2lsbCBoYXZlIHRvIGRvIHNvbWV0aGluZyBzcGVjaWFsIHRvIGluY2x1ZGUgIGEgJ3wnIGluIHtyaHN9LgpUaGVyZSBhcmUgdGhyZWUgbWV0aG9kczoKICAgdXNlCSAgICAgd29ya3Mgd2hlbgkJCSAgIGV4YW1wbGUJfgogICA8QmFyPiAgICAgJzwnIGlzIG5vdCBpbiAnY3BvcHRpb25zJwkgICA6bWFwIF9sIDohbHMgPEJhcj4gbW9yZV5NCiAgIFx8CSAgICAgJ2InIGlzIG5vdCBpbiAnY3BvcHRpb25zJwkgICA6bWFwIF9sIDohbHMgXHwgbW9yZV5NCiAgIF5WfAkgICAgIGFsd2F5cywgaW4gVmltIGFuZCBWaQkgICA6bWFwIF9sIDohbHMgXlZ8IG1vcmVeTQoKKGhlcmUgXlYgc3RhbmRzIGZvciBDVFJMLVY7IHRvIGdldCBvbmUgQ1RSTC1WIHlvdSBoYXZlIHRvIHR5cGUgaXQgdHdpY2U7IHlvdQpjYW5ub3QgdXNlIHRoZSA8PiBub3RhdGlvbiAiPEMtVj4iIGhlcmUpLgoKQWxsIHRocmVlIHdvcmsgd2hlbiB5b3UgdXNlIHRoZSBkZWZhdWx0IHNldHRpbmcgZm9yICdjcG9wdGlvbnMnLgoKV2hlbiAnYicgaXMgcHJlc2VudCBpbiAnY3BvcHRpb25zJywgIlx8IiB3aWxsIGJlIHJlY29nbml6ZWQgYXMgYSBtYXBwaW5nCmVuZGluZyBpbiBhICdcJyBhbmQgdGhlbiBhbm90aGVyIGNvbW1hbmQuICBUaGlzIGlzIFZpIGNvbXBhdGlibGUsIGJ1dAppbGxvZ2ljYWwgd2hlbiBjb21wYXJlZCB0byBvdGhlciBjb21tYW5kcy4KCgkJCQkJCQkqbWFwX3JldHVybioKV2hlbiB5b3UgaGF2ZSBhIG1hcHBpbmcgdGhhdCBjb250YWlucyBhbiBFeCBjb21tYW5kLCB5b3UgbmVlZCB0byBwdXQgYSBsaW5lCnRlcm1pbmF0b3IgYWZ0ZXIgaXQgdG8gaGF2ZSBpdCBleGVjdXRlZC4gIFRoZSB1c2Ugb2YgPENSPiBpcyByZWNvbW1lbmRlZCBmb3IKdGhpcyAoc2VlIHw8PnwpLiAgRXhhbXBsZTogPgogICA6bWFwICBfbHMgIDohbHMgLWwgJTxDUj46ZWNobyAidGhlIGVuZCI8Q1I+CgpUbyBhdm9pZCBtYXBwaW5nIG9mIHRoZSBjaGFyYWN0ZXJzIHlvdSB0eXBlIGluIGluc2VydCBvciBDb21tYW5kLWxpbmUgbW9kZSwKdHlwZSBhIENUUkwtViBmaXJzdC4gIFRoZSBtYXBwaW5nIGluIEluc2VydCBtb2RlIGlzIGRpc2FibGVkIGlmIHRoZSAncGFzdGUnCm9wdGlvbiBpcyBvbi4KCk5vdGUgdGhhdCB3aGVuIGFuIGVycm9yIGlzIGVuY291bnRlcmVkICh0aGF0IGNhdXNlcyBhbiBlcnJvciBtZXNzYWdlIG9yIGJlZXApCnRoZSByZXN0IG9mIHRoZSBtYXBwaW5nIGlzIG5vdCBleGVjdXRlZC4gIFRoaXMgaXMgVmktY29tcGF0aWJsZS4KCk5vdGUgdGhhdCB0aGUgc2Vjb25kIGNoYXJhY3RlciAoYXJndW1lbnQpIG9mIHRoZSBjb21tYW5kcyBAelp0VGZGW11ybSdgInYKYW5kIENUUkwtWCBpcyBub3QgbWFwcGVkLiAgVGhpcyB3YXMgZG9uZSB0byBiZSBhYmxlIHRvIHVzZSBhbGwgdGhlIG5hbWVkCnJlZ2lzdGVycyBhbmQgbWFya3MsIGV2ZW4gd2hlbiB0aGUgY29tbWFuZCB3aXRoIHRoZSBzYW1lIG5hbWUgaGFzIGJlZW4KbWFwcGVkLgoKCjEuNyBXSEFUIEtFWVMgVE8gTUFQCQkJCQkqbWFwLXdoaWNoLWtleXMqCgpJZiB5b3UgYXJlIGdvaW5nIHRvIG1hcCBzb21ldGhpbmcsIHlvdSB3aWxsIG5lZWQgdG8gY2hvb3NlIHdoaWNoIGtleShzKSB0byB1c2UKZm9yIHRoZSB7bGhzfS4gIFlvdSB3aWxsIGhhdmUgdG8gYXZvaWQga2V5cyB0aGF0IGFyZSB1c2VkIGZvciBWaW0gY29tbWFuZHMsCm90aGVyd2lzZSB5b3Ugd291bGQgbm90IGJlIGFibGUgdG8gdXNlIHRob3NlIGNvbW1hbmRzIGFueW1vcmUuICBIZXJlIGFyZSBhIGZldwpzdWdnZXN0aW9uczoKLSBGdW5jdGlvbiBrZXlzIDxGMj4sIDxGMz4sIGV0Yy4uICBBbHNvIHRoZSBzaGlmdGVkIGZ1bmN0aW9uIGtleXMgPFMtRjE+LAogIDxTLUYyPiwgZXRjLiAgTm90ZSB0aGF0IDxGMT4gaXMgYWxyZWFkeSB1c2VkIGZvciB0aGUgaGVscCBjb21tYW5kLgotIE1ldGEta2V5cyAod2l0aCB0aGUgQUxUIGtleSBwcmVzc2VkKS4gIERlcGVuZGluZyBvbiB5b3VyIGtleWJvYXJkIGFjY2VudGVkCiAgY2hhcmFjdGVycyBtYXkgYmUgdXNlZCBhcyB3ZWxsLiB8Om1hcC1hbHQta2V5c3wKLSBVc2UgdGhlICdfJyBvciAnLCcgY2hhcmFjdGVyIGFuZCB0aGVuIGFueSBvdGhlciBjaGFyYWN0ZXIuICBUaGUgIl8iIGFuZCAiLCIKICBjb21tYW5kcyBkbyBleGlzdCBpbiBWaW0gKHNlZSB8X3wgYW5kIHwsfCksIGJ1dCB5b3UgcHJvYmFibHkgbmV2ZXIgdXNlIHRoZW0uCi0gVXNlIGEga2V5IHRoYXQgaXMgYSBzeW5vbnltIGZvciBhbm90aGVyIGNvbW1hbmQuICBGb3IgZXhhbXBsZTogQ1RSTC1QIGFuZAogIENUUkwtTi4gIFVzZSBhbiBleHRyYSBjaGFyYWN0ZXIgdG8gYWxsb3cgbW9yZSBtYXBwaW5ncy4KLSBUaGUga2V5IGRlZmluZWQgYnkgPExlYWRlcj4gYW5kIG9uZSBvciBtb3JlIG90aGVyIGtleXMuICBUaGlzIGlzIGVzcGVjaWFsbHkKICB1c2VmdWwgaW4gc2NyaXB0cy4gfG1hcGxlYWRlcnwKClNlZSB0aGUgZmlsZSAiaW5kZXgiIGZvciBrZXlzIHRoYXQgYXJlIG5vdCB1c2VkIGFuZCB0aHVzIGNhbiBiZSBtYXBwZWQgd2l0aG91dApsb3NpbmcgYW55IGJ1aWx0aW4gZnVuY3Rpb24uICBZb3UgY2FuIGFsc28gdXNlICI6aGVscCB7a2V5fV5EIiB0byBmaW5kIG91dCBpZgphIGtleSBpcyB1c2VkIGZvciBzb21lIGNvbW1hbmQuICAoe2tleX0gaXMgdGhlIHNwZWNpZmljIGtleSB5b3Ugd2FudCB0byBmaW5kCm91dCBhYm91dCwgXkQgaXMgQ1RSTC1EKS4KCgoxLjggRVhBTVBMRVMJCQkJCQkqbWFwLWV4YW1wbGVzKgoKQSBmZXcgZXhhbXBsZXMgKGdpdmVuIGFzIHlvdSB0eXBlIHRoZW0sIGZvciAiPENSPiIgeW91IHR5cGUgZm91ciBjaGFyYWN0ZXJzOwp0aGUgJzwnIGZsYWcgbXVzdCBub3QgYmUgcHJlc2VudCBpbiAnY3BvcHRpb25zJyBmb3IgdGhpcyB0byB3b3JrKS4gPgoKICAgOm1hcCA8RjM+ICBvI2luY2x1ZGUKICAgOm1hcCA8TS1nPiAvZm9vPENSPmN3YmFyPEVzYz4KICAgOm1hcCBfeCAgICBkL0VORC9lPENSPgogICA6bWFwISBxcSAgIHF1YWRyaWxsaW9uIHF1ZXN0aW9ucwoKCk11bHRpcGx5aW5nIGEgY291bnQKCldoZW4geW91IHR5cGUgYSBjb3VudCBiZWZvcmUgdHJpZ2dlcmluZyBhIG1hcHBpbmcsIGl0J3MgbGlrZSB0aGUgY291bnQgd2FzCnR5cGVkIGJlZm9yZSB0aGUge2xoc30uICBGb3IgZXhhbXBsZSwgd2l0aCB0aGlzIG1hcHBpbmc6ID4KICAgOm1hcCA8RjQ+ICAzdwpUeXBpbmcgMjxGND4gd2lsbCByZXN1bHQgaW4gIjIzdyIuIFRodXMgbm90IG1vdmluZyAyICogMyB3b3JkcyBidXQgMjMgd29yZHMuCklmIHlvdSB3YW50IHRvIG11bHRpcGx5IGNvdW50cyB1c2UgdGhlIGV4cHJlc3Npb24gcmVnaXN0ZXI6ID4KICAgOm1hcCA8RjQ+ICBAPSczdyc8Q1I+ClRoZSBwYXJ0IGJldHdlZW4gcXVvdGVzIGlzIHRoZSBleHByZXNzaW9uIGJlaW5nIGV4ZWN1dGVkLiB8QD18CgoKMS45IFVTSU5HIE1BUFBJTkdTCQkJCQkqbWFwLXR5cGluZyoKClZpbSB3aWxsIGNvbXBhcmUgd2hhdCB5b3UgdHlwZSB3aXRoIHRoZSBzdGFydCBvZiBhIG1hcHBlZCBzZXF1ZW5jZS4gIElmIHRoZXJlCmlzIGFuIGluY29tcGxldGUgbWF0Y2gsIGl0IHdpbGwgZ2V0IG1vcmUgY2hhcmFjdGVycyB1bnRpbCB0aGVyZSBlaXRoZXIgaXMgYQpjb21wbGV0ZSBtYXRjaCBvciB1bnRpbCB0aGVyZSBpcyBubyBtYXRjaCBhdCBhbGwuICBFeGFtcGxlOiBJZiB5b3UgbWFwISAicXEiLAp0aGUgZmlyc3QgJ3EnIHdpbGwgbm90IGFwcGVhciBvbiB0aGUgc2NyZWVuIHVudGlsIHlvdSB0eXBlIGFub3RoZXIKY2hhcmFjdGVyLiAgVGhpcyBpcyBiZWNhdXNlIFZpbSBjYW5ub3Qga25vdyBpZiB0aGUgbmV4dCBjaGFyYWN0ZXIgd2lsbCBiZSBhCidxJyBvciBub3QuICBJZiB0aGUgJ3RpbWVvdXQnIG9wdGlvbiBpcyBvbiAod2hpY2ggaXMgdGhlIGRlZmF1bHQpIFZpbSB3aWxsCm9ubHkgd2FpdCBmb3Igb25lIHNlY29uZCAob3IgYXMgbG9uZyBhcyBzcGVjaWZpZWQgd2l0aCB0aGUgJ3RpbWVvdXRsZW4nCm9wdGlvbikuICBBZnRlciB0aGF0IGl0IGFzc3VtZXMgdGhhdCB0aGUgJ3EnIGlzIHRvIGJlIGludGVycHJldGVkIGFzIHN1Y2guICBJZgp5b3UgdHlwZSBzbG93bHksIG9yIHlvdXIgc3lzdGVtIGlzIHNsb3csIHJlc2V0IHRoZSAndGltZW91dCcgb3B0aW9uLiAgVGhlbiB5b3UKbWlnaHQgd2FudCB0byBzZXQgdGhlICd0dGltZW91dCcgb3B0aW9uLgoKCQkJCQkJCSptYXAta2V5cy1mYWlscyoKVGhlcmUgYXJlIHNpdHVhdGlvbnMgd2hlcmUga2V5IGNvZGVzIG1pZ2h0IG5vdCBiZSByZWNvZ25pemVkOgotIFZpbSBjYW4gb25seSByZWFkIHBhcnQgb2YgdGhlIGtleSBjb2RlLiAgTW9zdGx5IHRoaXMgaXMgb25seSB0aGUgZmlyc3QKICBjaGFyYWN0ZXIuICBUaGlzIGhhcHBlbnMgb24gc29tZSBVbml4IHZlcnNpb25zIGluIGFuIHh0ZXJtLgotIFRoZSBrZXkgY29kZSBpcyBhZnRlciBjaGFyYWN0ZXIocykgdGhhdCBhcmUgbWFwcGVkLiAgRS5nLiwgIjxGMT48RjE+IiBvcgogICJnPEYxPiIuCgpUaGUgcmVzdWx0IGlzIHRoYXQgdGhlIGtleSBjb2RlIGlzIG5vdCByZWNvZ25pemVkIGluIHRoaXMgc2l0dWF0aW9uLCBhbmQgdGhlCm1hcHBpbmcgZmFpbHMuICBUaGVyZSBhcmUgdHdvIGFjdGlvbnMgbmVlZGVkIHRvIGF2b2lkIHRoaXMgcHJvYmxlbToKCi0gUmVtb3ZlIHRoZSAnSycgZmxhZyBmcm9tICdjcG9wdGlvbnMnLiAgVGhpcyB3aWxsIG1ha2UgVmltIHdhaXQgZm9yIHRoZSByZXN0CiAgb2YgdGhlIGNoYXJhY3RlcnMgb2YgdGhlIGZ1bmN0aW9uIGtleS4KLSBXaGVuIHVzaW5nIDxGMT4gdG8gPEY0PiB0aGUgYWN0dWFsIGtleSBjb2RlIGdlbmVyYXRlZCBtYXkgY29ycmVzcG9uZCB0bwogIDx4RjE+IHRvIDx4RjQ+LiAgVGhlcmUgYXJlIG1hcHBpbmdzIGZyb20gPHhGMT4gdG8gPEYxPiwgPHhGMj4gdG8gPEYyPiwgZXRjLiwKICBidXQgdGhlc2UgYXJlIG5vdCByZWNvZ25pemVkIGFmdGVyIGFub3RoZXIgaGFsZiBhIG1hcHBpbmcuICBNYWtlIHN1cmUgdGhlCiAga2V5IGNvZGVzIGZvciA8RjE+IHRvIDxGND4gYXJlIGNvcnJlY3Q6ID4KCTpzZXQgPEYxPj08dHlwZSBDVFJMLVY+PHR5cGUgRjE+CjwgVHlwZSB0aGUgPEYxPiBhcyBmb3VyIGNoYXJhY3RlcnMuICBUaGUgcGFydCBhZnRlciB0aGUgIj0iIG11c3QgYmUgZG9uZSB3aXRoCiAgdGhlIGFjdHVhbCBrZXlzLCBub3QgdGhlIGxpdGVyYWwgdGV4dC4KQW5vdGhlciBzb2x1dGlvbiBpcyB0byB1c2UgdGhlIGFjdHVhbCBrZXkgY29kZSBpbiB0aGUgbWFwcGluZyBmb3IgdGhlIHNlY29uZApzcGVjaWFsIGtleTogPgoJOm1hcCA8RjE+PEVzYz5PUCA6ZWNobyAieWVzIjxDUj4KRG9uJ3QgdHlwZSBhIHJlYWwgPEVzYz4sIFZpbSB3aWxsIHJlY29nbml6ZSB0aGUga2V5IGNvZGUgYW5kIHJlcGxhY2UgaXQgd2l0aAo8RjE+IGFueXdheS4KCkFub3RoZXIgcHJvYmxlbSBtYXkgYmUgdGhhdCB3aGVuIGtlZXBpbmcgQUxUIG9yIE1ldGEgcHJlc3NlZCB0aGUgdGVybWluYWwKcHJlcGVuZHMgRVNDIGluc3RlYWQgb2Ygc2V0dGluZyB0aGUgOHRoIGJpdC4gIFNlZSB8Om1hcC1hbHQta2V5c3wuCgoJCQkJCQkqcmVjdXJzaXZlX21hcHBpbmcqCklmIHlvdSBpbmNsdWRlIHRoZSB7bGhzfSBpbiB0aGUge3Joc30geW91IGhhdmUgYSByZWN1cnNpdmUgbWFwcGluZy4gIFdoZW4Ke2xoc30gaXMgdHlwZWQsIGl0IHdpbGwgYmUgcmVwbGFjZWQgd2l0aCB7cmhzfS4gIFdoZW4gdGhlIHtsaHN9IHdoaWNoIGlzCmluY2x1ZGVkIGluIHtyaHN9IGlzIGVuY291bnRlcmVkIGl0IHdpbGwgYmUgcmVwbGFjZWQgd2l0aCB7cmhzfSwgYW5kIHNvIG9uLgpUaGlzIG1ha2VzIGl0IHBvc3NpYmxlIHRvIHJlcGVhdCBhIGNvbW1hbmQgYW4gaW5maW5pdGUgbnVtYmVyIG9mIHRpbWVzLiAgVGhlCm9ubHkgcHJvYmxlbSBpcyB0aGF0IHRoZSBvbmx5IHdheSB0byBzdG9wIHRoaXMgaXMgYnkgY2F1c2luZyBhbiBlcnJvci4gIFRoZQptYWNyb3MgdG8gc29sdmUgYSBtYXplIHVzZXMgdGhpcywgbG9vayB0aGVyZSBmb3IgYW4gZXhhbXBsZS4gIFRoZXJlIGlzIG9uZQpleGNlcHRpb246IElmIHRoZSB7cmhzfSBzdGFydHMgd2l0aCB7bGhzfSwgdGhlIGZpcnN0IGNoYXJhY3RlciBpcyBub3QgbWFwcGVkCmFnYWluICh0aGlzIGlzIFZpIGNvbXBhdGlibGUpLgpGb3IgZXhhbXBsZTogPgogICA6bWFwIGFiIGFiY2QKd2lsbCBleGVjdXRlIHRoZSAiYSIgY29tbWFuZCBhbmQgaW5zZXJ0ICJiY2QiIGluIHRoZSB0ZXh0LiAgVGhlICJhYiIgaW4gdGhlCntyaHN9IHdpbGwgbm90IGJlIG1hcHBlZCBhZ2Fpbi4KCklmIHlvdSB3YW50IHRvIGV4Y2hhbmdlIHRoZSBtZWFuaW5nIG9mIHR3byBrZXlzIHlvdSBzaG91bGQgdXNlIHRoZSA6bm9yZW1hcApjb21tYW5kLiAgRm9yIGV4YW1wbGU6ID4KICAgOm5vcmVtYXAgayBqCiAgIDpub3JlbWFwIGogawpUaGlzIHdpbGwgZXhjaGFuZ2UgdGhlIGN1cnNvciB1cCBhbmQgZG93biBjb21tYW5kcy4KCldpdGggdGhlIG5vcm1hbCA6bWFwIGNvbW1hbmQsIHdoZW4gdGhlICdyZW1hcCcgb3B0aW9uIGlzIG9uLCBtYXBwaW5nIHRha2VzCnBsYWNlIHVudGlsIHRoZSB0ZXh0IGlzIGZvdW5kIG5vdCB0byBiZSBhIHBhcnQgb2YgYSB7bGhzfS4gIEZvciBleGFtcGxlLCBpZgp5b3UgdXNlOiA+CiAgIDptYXAgeCB5CiAgIDptYXAgeSB4ClZpbSB3aWxsIHJlcGxhY2UgeCB3aXRoIHksIGFuZCB0aGVuIHkgd2l0aCB4LCBldGMuICBXaGVuIHRoaXMgaGFzIGhhcHBlbmVkCidtYXhtYXBkZXB0aCcgdGltZXMgKGRlZmF1bHQgMTAwMCksIFZpbSB3aWxsIGdpdmUgdGhlIGVycm9yIG1lc3NhZ2UKInJlY3Vyc2l2ZSBtYXBwaW5nIi4KCgkJCQkJCQkqOm1hcC11bmRvKgpJZiB5b3UgaW5jbHVkZSBhbiB1bmRvIGNvbW1hbmQgaW5zaWRlIGEgbWFwcGVkIHNlcXVlbmNlLCB0aGlzIHdpbGwgYnJpbmcgdGhlCnRleHQgYmFjayBpbiB0aGUgc3RhdGUgYmVmb3JlIGV4ZWN1dGluZyB0aGUgbWFjcm8uICBUaGlzIGlzIGNvbXBhdGlibGUgd2l0aAp0aGUgb3JpZ2luYWwgVmksIGFzIGxvbmcgYXMgdGhlcmUgaXMgb25seSBvbmUgdW5kbyBjb21tYW5kIGluIHRoZSBtYXBwZWQKc2VxdWVuY2UgKGhhdmluZyB0d28gdW5kbyBjb21tYW5kcyBpbiBhIG1hcHBlZCBzZXF1ZW5jZSBkaWQgbm90IG1ha2Ugc2Vuc2UKaW4gdGhlIG9yaWdpbmFsIFZpLCB5b3Ugd291bGQgZ2V0IGJhY2sgdGhlIHRleHQgYmVmb3JlIHRoZSBmaXJzdCB1bmRvKS4KCgoxLjEwIE1BUFBJTkcgQUxULUtFWVMJCQkJCSo6bWFwLWFsdC1rZXlzKgoKSW4gdGhlIEdVSSBWaW0gaGFuZGxlcyB0aGUgQWx0IGtleSBpdHNlbGYsIHRodXMgbWFwcGluZyBrZXlzIHdpdGggQUxUIHNob3VsZAphbHdheXMgd29yay4gIEJ1dCBpbiBhIHRlcm1pbmFsIFZpbSBnZXRzIGEgc2VxdWVuY2Ugb2YgYnl0ZXMgYW5kIGhhcyB0byBmaWd1cmUKb3V0IHdoZXRoZXIgQUxUIHdhcyBwcmVzc2VkIG9yIG5vdC4KCkJ5IGRlZmF1bHQgVmltIGFzc3VtZXMgdGhhdCBwcmVzc2luZyB0aGUgQUxUIGtleSBzZXRzIHRoZSA4dGggYml0IG9mIGEgdHlwZWQKY2hhcmFjdGVyLiAgTW9zdCBkZWNlbnQgdGVybWluYWxzIGNhbiB3b3JrIHRoYXQgd2F5LCBzdWNoIGFzIHh0ZXJtLCBhdGVybSBhbmQKcnh2dC4gIElmIHlvdXIgPEEtaz4gbWFwcGluZ3MgZG9uJ3Qgd29yayBpdCBtaWdodCBiZSB0aGF0IHRoZSB0ZXJtaW5hbCBpcwpwcmVmaXhpbmcgdGhlIGNoYXJhY3RlciB3aXRoIGFuIEVTQyBjaGFyYWN0ZXIuICBCdXQgeW91IGNhbiBqdXN0IGFzIHdlbGwgdHlwZQpFU0MgYmVmb3JlIGEgY2hhcmFjdGVyLCB0aHVzIFZpbSBkb2Vzbid0IGtub3cgd2hhdCBoYXBwZW5lZCAoZXhjZXB0IGZvcgpjaGVja2luZyB0aGUgZGVsYXkgYmV0d2VlbiBjaGFyYWN0ZXJzLCB3aGljaCBpcyBub3QgcmVsaWFibGUpLgoKQXMgb2YgdGhpcyB3cml0aW5nLCBzb21lIG1haW5zdHJlYW0gdGVybWluYWxzIGxpa2UgZ25vbWUtdGVybWluYWwgYW5kIGtvbnNvbGUKdXNlIHRoZSBFU0MgcHJlZml4LiAgVGhlcmUgZG9lc24ndCBhcHBlYXIgYSB3YXkgdG8gaGF2ZSB0aGVtIHVzZSB0aGUgOHRoIGJpdAppbnN0ZWFkLiAgWHRlcm0gc2hvdWxkIHdvcmsgd2VsbCBieSBkZWZhdWx0LiAgQXRlcm0gYW5kIHJ4dnQgc2hvdWxkIHdvcmsgd2VsbAp3aGVuIHN0YXJ0ZWQgd2l0aCB0aGUgIi0tbWV0YTgiIGFyZ3VtZW50LiAgWW91IGNhbiBhbHNvIHR3ZWFrIHJlc291cmNlcyBsaWtlCiJtZXRhU2VuZHNFc2NhcGUiLCAiZWlnaHRCaXRJbnB1dCIgYW5kICJlaWdodEJpdE91dHB1dCIuCgpPbiB0aGUgTGludXggY29uc29sZSwgdGhpcyBiZWhhdmlvciBjYW4gYmUgdG9nZ2xlZCB3aXRoIHRoZSAic2V0bWV0YW1vZGUiCmNvbW1hbmQuICBCZWFyIGluIG1pbmQgdGhhdCBub3QgdXNpbmcgYW4gRVNDIHByZWZpeCBjb3VsZCBnZXQgeW91IGluIHRyb3VibGUKd2l0aCBvdGhlciBwcm9ncmFtcy4gIFlvdSBzaG91bGQgbWFrZSBzdXJlIHRoYXQgYmFzaCBoYXMgdGhlICJjb252ZXJ0LW1ldGEiCm9wdGlvbiBzZXQgdG8gIm9uIiBpbiBvcmRlciBmb3IgeW91ciBNZXRhIGtleWJpbmRpbmdzIHRvIHN0aWxsIHdvcmsgb24gaXQKKGl0J3MgdGhlIGRlZmF1bHQgcmVhZGxpbmUgYmVoYXZpb3IsIHVubGVzcyBjaGFuZ2VkIGJ5IHNwZWNpZmljIHN5c3RlbQpjb25maWd1cmF0aW9uKS4gIEZvciB0aGF0LCB5b3UgY2FuIGFkZCB0aGUgbGluZTogPgoKCXNldCBjb252ZXJ0LW1ldGEgb24KCnRvIHlvdXIgfi8uaW5wdXRyYyBmaWxlLiBJZiB5b3UncmUgY3JlYXRpbmcgdGhlIGZpbGUsIHlvdSBtaWdodCB3YW50IHRvIHVzZTogPgoKCSRpbmNsdWRlIC9ldGMvaW5wdXRyYwoKYXMgdGhlIGZpcnN0IGxpbmUsIGlmIHRoYXQgZmlsZSBleGlzdHMgb24geW91ciBzeXN0ZW0sIHRvIGtlZXAgZ2xvYmFsIG9wdGlvbnMuClRoaXMgbWF5IGNhdXNlIGEgcHJvYmxlbSBmb3IgZW50ZXJpbmcgc3BlY2lhbCBjaGFyYWN0ZXJzLCBzdWNoIGFzIHRoZSB1bWxhdXQuClRoZW4geW91IHNob3VsZCB1c2UgQ1RSTC1WIGJlZm9yZSB0aGF0IGNoYXJhY3Rlci4KCkJlYXIgaW4gbWluZCB0aGF0IGNvbnZlcnQtbWV0YSBoYXMgYmVlbiByZXBvcnRlZCB0byBoYXZlIHRyb3VibGVzIHdoZW4gdXNlZCBpbgpVVEYtOCBsb2NhbGVzLiAgT24gdGVybWluYWxzIGxpa2UgeHRlcm0sIHRoZSAibWV0YVNlbmRzRXNjYXBlIiByZXNvdXJjZSBjYW4gYmUKdG9nZ2xlZCBvbiB0aGUgZmx5IHRocm91Z2ggdGhlICJNYWluIE9wdGlvbnMiIG1lbnUsIGJ5IHByZXNzaW5nIEN0cmwtTGVmdENsaWNrCm9uIHRoZSB0ZXJtaW5hbDsgdGhhdCdzIGEgZ29vZCBsYXN0IHJlc291cmNlIGluIGNhc2UgeW91IHdhbnQgdG8gc2VuZCBFU0Mgd2hlbgp1c2luZyBvdGhlciBhcHBsaWNhdGlvbnMgYnV0IG5vdCB3aGVuIGluc2lkZSBWSU0uCgoKMS4xMSBNQVBQSU5HIEFOIE9QRVJBVE9SCQkJCSo6bWFwLW9wZXJhdG9yKgoKQW4gb3BlcmF0b3IgaXMgdXNlZCBiZWZvcmUgYSB7bW90aW9ufSBjb21tYW5kLiAgVG8gZGVmaW5lIHlvdXIgb3duIG9wZXJhdG9yCnlvdSBtdXN0IGNyZWF0ZSBtYXBwaW5nIHRoYXQgZmlyc3Qgc2V0cyB0aGUgJ29wZXJhdG9yZnVuYycgb3B0aW9uIGFuZCB0aGVuCmludm9rZSB0aGUgfGdAfCBvcGVyYXRvci4gIEFmdGVyIHRoZSB1c2VyIHR5cGVzIHRoZSB7bW90aW9ufSBjb21tYW5kIHRoZQpzcGVjaWZpZWQgZnVuY3Rpb24gd2lsbCBiZSBjYWxsZWQuCgoJCQkJCQkJKmdAKiAqRTc3NCogKkU3NzUqCmdAe21vdGlvbn0JCUNhbGwgdGhlIGZ1bmN0aW9uIHNldCBieSB0aGUgJ29wZXJhdG9yZnVuYycgb3B0aW9uLgoJCQlUaGUgJ1sgbWFyayBpcyBwb3NpdGlvbmVkIGF0IHRoZSBzdGFydCBvZiB0aGUgdGV4dAoJCQltb3ZlZCBvdmVyIGJ5IHttb3Rpb259LCB0aGUgJ10gbWFyayBvbiB0aGUgbGFzdAoJCQljaGFyYWN0ZXIgb2YgdGhlIHRleHQuCgkJCVRoZSBmdW5jdGlvbiBpcyBjYWxsZWQgd2l0aCBvbmUgU3RyaW5nIGFyZ3VtZW50OgoJCQkgICAgImxpbmUiCXttb3Rpb259IHdhcyB8bGluZXdpc2V8CgkJCSAgICAiY2hhciIJe21vdGlvbn0gd2FzIHxjaGFyYWN0ZXJ3aXNlfAoJCQkgICAgImJsb2NrIgl7bW90aW9ufSB3YXMgfGJsb2Nrd2lzZS12aXN1YWx8CgkJCUFsdGhvdWdoICJibG9jayIgd291bGQgcmFyZWx5IGFwcGVhciwgc2luY2UgaXQgY2FuCgkJCW9ubHkgcmVzdWx0IGZyb20gVmlzdWFsIG1vZGUgd2hlcmUgImdAIiBpcyBub3QgdXNlZnVsLgoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZXZhbHwKCQkJZmVhdHVyZX0KCkhlcmUgaXMgYW4gZXhhbXBsZSB0aGF0IGNvdW50cyB0aGUgbnVtYmVyIG9mIHNwYWNlcyB3aXRoIDxGND46ID4KCglubWFwIDxzaWxlbnQ+IDxGND4gOnNldCBvcGZ1bmM9Q291bnRTcGFjZXM8Q1I+Z0AKCXZtYXAgPHNpbGVudD4gPEY0PiA6PEMtVT5jYWxsIENvdW50U3BhY2VzKHZpc3VhbG1vZGUoKSwgMSk8Q1I+CgoJZnVuY3Rpb24hIENvdW50U3BhY2VzKHR5cGUsIC4uLikKCSAgbGV0IHNlbF9zYXZlID0gJnNlbGVjdGlvbgoJICBsZXQgJnNlbGVjdGlvbiA9ICJpbmNsdXNpdmUiCgkgIGxldCByZWdfc2F2ZSA9IEBACgoJICBpZiBhOjAgICIgSW52b2tlZCBmcm9tIFZpc3VhbCBtb2RlLCB1c2UgJzwgYW5kICc+IG1hcmtzLgoJICAgIHNpbGVudCBleGUgIm5vcm1hbCEgYDwiIC4gYTp0eXBlIC4gImA+eSIKCSAgZWxzZWlmIGE6dHlwZSA9PSAnbGluZScKCSAgICBzaWxlbnQgZXhlICJub3JtYWwhICdbViddeSIKCSAgZWxzZWlmIGE6dHlwZSA9PSAnYmxvY2snCgkgICAgc2lsZW50IGV4ZSAibm9ybWFsISBgW1w8Qy1WPmBdeSIKCSAgZWxzZQoJICAgIHNpbGVudCBleGUgIm5vcm1hbCEgYFt2YF15IgoJICBlbmRpZgoKCSAgZWNob21zZyBzdHJsZW4oc3Vic3RpdHV0ZShAQCwgJ1teIF0nLCAnJywgJ2cnKSkKCgkgIGxldCAmc2VsZWN0aW9uID0gc2VsX3NhdmUKCSAgbGV0IEBAID0gcmVnX3NhdmUKCWVuZGZ1bmN0aW9uCgpOb3RlIHRoYXQgdGhlICdzZWxlY3Rpb24nIG9wdGlvbiBpcyB0ZW1wb3JhcmlseSBzZXQgdG8gImluY2x1c2l2ZSIgdG8gYmUgYWJsZQp0byB5YW5rIGV4YWN0bHkgdGhlIHJpZ2h0IHRleHQgYnkgdXNpbmcgVmlzdWFsIG1vZGUgZnJvbSB0aGUgJ1sgdG8gdGhlICddCm1hcmsuCgpBbHNvIG5vdGUgdGhhdCB0aGVyZSBpcyBhIHNlcGFyYXRlIG1hcHBpbmcgZm9yIFZpc3VhbCBtb2RlLiAgSXQgcmVtb3ZlcyB0aGUKIic8LCc+IiByYW5nZSB0aGF0ICI6IiBpbnNlcnRzIGluIFZpc3VhbCBtb2RlIGFuZCBpbnZva2VzIHRoZSBmdW5jdGlvbiB3aXRoCnZpc3VhbG1vZGUoKSBhbmQgYW4gZXh0cmEgYXJndW1lbnQuCgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KMi4gQWJicmV2aWF0aW9ucwkJCSphYmJyZXZpYXRpb25zKiAqQWJicmV2aWF0aW9ucyoKCkFiYnJldmlhdGlvbnMgYXJlIHVzZWQgaW4gSW5zZXJ0IG1vZGUsIFJlcGxhY2UgbW9kZSBhbmQgQ29tbWFuZC1saW5lIG1vZGUuCklmIHlvdSBlbnRlciBhIHdvcmQgdGhhdCBpcyBhbiBhYmJyZXZpYXRpb24sIGl0IGlzIHJlcGxhY2VkIHdpdGggdGhlIHdvcmQgaXQKc3RhbmRzIGZvci4gIFRoaXMgY2FuIGJlIHVzZWQgdG8gc2F2ZSB0eXBpbmcgZm9yIG9mdGVuIHVzZWQgbG9uZyB3b3Jkcy4gIEFuZAp5b3UgY2FuIHVzZSBpdCB0byBhdXRvbWF0aWNhbGx5IGNvcnJlY3Qgb2J2aW91cyBzcGVsbGluZyBlcnJvcnMuCkV4YW1wbGVzOgoKCTppYWIgbXMgTWljcm9zb2Z0Cgk6aWFiIHRpaHMgdGhpcwoKVGhlcmUgYXJlIHRocmVlIHR5cGVzIG9mIGFiYnJldmlhdGlvbnM6CgpmdWxsLWlkCSAgVGhlICJmdWxsLWlkIiB0eXBlIGNvbnNpc3RzIGVudGlyZWx5IG9mIGtleXdvcmQgY2hhcmFjdGVycyAobGV0dGVycwoJICBhbmQgY2hhcmFjdGVycyBmcm9tICdpc2tleXdvcmQnIG9wdGlvbikuICBUaGlzIGlzIHRoZSBtb3N0IGNvbW1vbgoJICBhYmJyZXZpYXRpb24uCgoJICBFeGFtcGxlczogImZvbyIsICJnMyIsICItMSIKCmVuZC1pZAkgIFRoZSAiZW5kLWlkIiB0eXBlIGVuZHMgaW4gYSBrZXl3b3JkIGNoYXJhY3RlciwgYnV0IGFsbCB0aGUgb3RoZXIKCSAgY2hhcmFjdGVycyBhcmUgbm90IGtleXdvcmQgY2hhcmFjdGVycy4KCgkgIEV4YW1wbGVzOiAiI2kiLCAiLi5mIiwgIiQvNyIKCm5vbi1pZAkgIFRoZSAibm9uLWlkIiB0eXBlIGVuZHMgaW4gYSBub24ta2V5d29yZCBjaGFyYWN0ZXIsIHRoZSBvdGhlcgoJICBjaGFyYWN0ZXJzIG1heSBiZSBvZiBhbnkgdHlwZSwgZXhjbHVkaW5nIHNwYWNlIGFuZCB0YWIuICB7dGhpcyB0eXBlCgkgIGlzIG5vdCBzdXBwb3J0ZWQgYnkgVml9CgoJICBFeGFtcGxlczogImRlZiMiLCAiNC83JCIKCkV4YW1wbGVzIG9mIHN0cmluZ3MgdGhhdCBjYW5ub3QgYmUgYWJicmV2aWF0aW9uczogImEuYiIsICIjZGVmIiwgImEgYiIsICJfJHIiCgpBbiBhYmJyZXZpYXRpb24gaXMgb25seSByZWNvZ25pemVkIHdoZW4geW91IHR5cGUgYSBub24ta2V5d29yZCBjaGFyYWN0ZXIuClRoaXMgY2FuIGFsc28gYmUgdGhlIDxFc2M+IHRoYXQgZW5kcyBpbnNlcnQgbW9kZSBvciB0aGUgPENSPiB0aGF0IGVuZHMgYQpjb21tYW5kLiAgVGhlIG5vbi1rZXl3b3JkIGNoYXJhY3RlciB3aGljaCBlbmRzIHRoZSBhYmJyZXZpYXRpb24gaXMgaW5zZXJ0ZWQKYWZ0ZXIgdGhlIGV4cGFuZGVkIGFiYnJldmlhdGlvbi4gIEFuIGV4Y2VwdGlvbiB0byB0aGlzIGlzIHRoZSBjaGFyYWN0ZXIgPEMtXT4sCndoaWNoIGlzIHVzZWQgdG8gZXhwYW5kIGFuIGFiYnJldmlhdGlvbiB3aXRob3V0IGluc2VydGluZyBhbnkgZXh0cmEKY2hhcmFjdGVycy4KCkV4YW1wbGU6ID4KICAgOmFiIGhoCWhlbGxvCjwJICAgICJoaDxTcGFjZT4iIGlzIGV4cGFuZGVkIHRvICJoZWxsbzxTcGFjZT4iCgkgICAgImhoPEMtXT4iIGlzIGV4cGFuZGVkIHRvICJoZWxsbyIKClRoZSBjaGFyYWN0ZXJzIGJlZm9yZSB0aGUgY3Vyc29yIG11c3QgbWF0Y2ggdGhlIGFiYnJldmlhdGlvbi4gIEVhY2ggdHlwZSBoYXMKYW4gYWRkaXRpb25hbCBydWxlOgoKZnVsbC1pZAkgIEluIGZyb250IG9mIHRoZSBtYXRjaCBpcyBhIG5vbi1rZXl3b3JkIGNoYXJhY3Rlciwgb3IgdGhpcyBpcyB3aGVyZQoJICB0aGUgbGluZSBvciBpbnNlcnRpb24gc3RhcnRzLiAgRXhjZXB0aW9uOiBXaGVuIHRoZSBhYmJyZXZpYXRpb24gaXMKCSAgb25seSBvbmUgY2hhcmFjdGVyLCBpdCBpcyBub3QgcmVjb2duaXplZCBpZiB0aGVyZSBpcyBhIG5vbi1rZXl3b3JkCgkgIGNoYXJhY3RlciBpbiBmcm9udCBvZiBpdCwgb3RoZXIgdGhhbiBhIHNwYWNlIG9yIGEgdGFiLgoKZW5kLWlkCSAgSW4gZnJvbnQgb2YgdGhlIG1hdGNoIGlzIGEga2V5d29yZCBjaGFyYWN0ZXIsIG9yIGEgc3BhY2Ugb3IgYSB0YWIsCgkgIG9yIHRoaXMgaXMgd2hlcmUgdGhlIGxpbmUgb3IgaW5zZXJ0aW9uIHN0YXJ0cy4KCm5vbi1pZAkgIEluIGZyb250IG9mIHRoZSBtYXRjaCBpcyBhIHNwYWNlLCB0YWIgb3IgdGhlIHN0YXJ0IG9mIHRoZSBsaW5lIG9yCgkgIHRoZSBpbnNlcnRpb24uCgpFeGFtcGxlczogKHtDVVJTT1J9IGlzIHdoZXJlIHlvdSB0eXBlIGEgbm9uLWtleXdvcmQgY2hhcmFjdGVyKSA+CiAgIDphYiBmb28gICBmb3VyIG9sZCBvdHRlcnMKPAkJIiBmb297Q1VSU09SfSIJICBpcyBleHBhbmRlZCB0byAiIGZvdXIgb2xkIG90dGVycyIKCQkiIGZvb2JhcntDVVJTT1J9IiBpcyBub3QgZXhwYW5kZWQKCQkiYmFyZm9ve0NVUlNPUn0iICBpcyBub3QgZXhwYW5kZWQKPgogICA6YWIgI2kgI2luY2x1ZGUKPAkJIiNpe0NVUlNPUn0iCSAgaXMgZXhwYW5kZWQgdG8gIiNpbmNsdWRlIgoJCSI+I2l7Q1VSU09SfSIJICBpcyBub3QgZXhwYW5kZWQKPgogICA6YWIgOzsgPGVuZG9mbGluZT4KPAkJInRlc3Q7OyIJICBpcyBub3QgZXhwYW5kZWQKCQkidGVzdCA7OyIJICBpcyBleHBhbmRlZCB0byAidGVzdCA8ZW5kb2ZsaW5lPiIKClRvIGF2b2lkIHRoZSBhYmJyZXZpYXRpb24gaW4gaW5zZXJ0IG1vZGU6IFR5cGUgcGFydCBvZiB0aGUgYWJicmV2aWF0aW9uLCBleGl0Cmluc2VydCBtb2RlIHdpdGggPEVzYz4sIHJlLWVudGVyIGluc2VydCBtb2RlIHdpdGggImEiIGFuZCB0eXBlIHRoZSByZXN0LiAgT3IKdHlwZSBDVFJMLVYgYmVmb3JlIHRoZSBjaGFyYWN0ZXIgYWZ0ZXIgdGhlIGFiYnJldmlhdGlvbi4KVG8gYXZvaWQgdGhlIGFiYnJldmlhdGlvbiBpbiBDb21tYW5kLWxpbmUgbW9kZTogVHlwZSBDVFJMLVYgdHdpY2Ugc29tZXdoZXJlIGluCnRoZSBhYmJyZXZpYXRpb24gdG8gYXZvaWQgaXQgdG8gYmUgcmVwbGFjZWQuICBBIENUUkwtViBpbiBmcm9udCBvZiBhIG5vcm1hbApjaGFyYWN0ZXIgaXMgbW9zdGx5IGlnbm9yZWQgb3RoZXJ3aXNlLgoKSXQgaXMgcG9zc2libGUgdG8gbW92ZSB0aGUgY3Vyc29yIGFmdGVyIGFuIGFiYnJldmlhdGlvbjogPgogICA6aWFiIGlmIGlmICgpPExlZnQ+ClRoaXMgZG9lcyBub3Qgd29yayBpZiAnY3BvcHRpb25zJyBpbmNsdWRlcyB0aGUgJzwnIGZsYWcuIHw8PnwKCllvdSBjYW4gZXZlbiBkbyBtb3JlIGNvbXBsaWNhdGVkIHRoaW5ncy4gIEZvciBleGFtcGxlLCB0byBjb25zdW1lIHRoZSBzcGFjZQp0eXBlZCBhZnRlciBhbiBhYmJyZXZpYXRpb246ID4KICAgZnVuYyBFYXRjaGFyKHBhdCkKICAgICAgbGV0IGMgPSBucjJjaGFyKGdldGNoYXIoMCkpCiAgICAgIHJldHVybiAoYyA9fiBhOnBhdCkgPyAnJyA6IGMKICAgZW5kZnVuYwogICBpYWJiciA8c2lsZW50PiBpZiBpZiAoKTxMZWZ0PjxDLVI+PUVhdGNoYXIoJ1xzJyk8Q1I+CgpUaGVyZSBhcmUgbm8gZGVmYXVsdCBhYmJyZXZpYXRpb25zLgoKQWJicmV2aWF0aW9ucyBhcmUgbmV2ZXIgcmVjdXJzaXZlLiAgWW91IGNhbiB1c2UgIjphYiBmIGYtby1vIiB3aXRob3V0IGFueQpwcm9ibGVtLiAgQnV0IGFiYnJldmlhdGlvbnMgY2FuIGJlIG1hcHBlZC4gIHtzb21lIHZlcnNpb25zIG9mIFZpIHN1cHBvcnQKcmVjdXJzaXZlIGFiYnJldmlhdGlvbnMsIGZvciBubyBhcHBhcmVudCByZWFzb259CgpBYmJyZXZpYXRpb25zIGFyZSBkaXNhYmxlZCBpZiB0aGUgJ3Bhc3RlJyBvcHRpb24gaXMgb24uCgoJCQkJKjphYmJyZXZpYXRlLWxvY2FsKiAqOmFiYnJldmlhdGUtPGJ1ZmZlcj4qCkp1c3QgbGlrZSBtYXBwaW5ncywgYWJicmV2aWF0aW9ucyBjYW4gYmUgbG9jYWwgdG8gYSBidWZmZXIuICBUaGlzIGlzIG1vc3RseQp1c2VkIGluIGEgfGZpbGV0eXBlLXBsdWdpbnwgZmlsZS4gIEV4YW1wbGUgZm9yIGEgQyBwbHVnaW4gZmlsZTogPgoJOmFiYiA8YnVmZmVyPiBGRiAgZm9yIChpID0gMDsgaSA8IDsgKytpKQo8CgkJCQkJCSo6YWIqICo6YWJicmV2aWF0ZSoKOmFiW2JyZXZpYXRlXQkJbGlzdCBhbGwgYWJicmV2aWF0aW9ucy4gIFRoZSBjaGFyYWN0ZXIgaW4gdGhlIGZpcnN0CgkJCWNvbHVtbiBpbmRpY2F0ZXMgdGhlIG1vZGUgd2hlcmUgdGhlIGFiYnJldmlhdGlvbiBpcwoJCQl1c2VkOiAnaScgZm9yIGluc2VydCBtb2RlLCAnYycgZm9yIENvbW1hbmQtbGluZQoJCQltb2RlLCAnIScgZm9yIGJvdGguICBUaGVzZSBhcmUgdGhlIHNhbWUgYXMgZm9yCgkJCW1hcHBpbmdzLCBzZWUgfG1hcC1saXN0aW5nfC4KCgkJCQkJCSo6YWJicmV2aWF0ZS12ZXJib3NlKgpXaGVuICd2ZXJib3NlJyBpcyBub24temVybywgbGlzdGluZyBhbiBhYmJyZXZpYXRpb24gd2lsbCBhbHNvIGRpc3BsYXkgd2hlcmUgaXQKd2FzIGxhc3QgZGVmaW5lZC4gIEV4YW1wbGU6ID4KCgk6dmVyYm9zZSBhYmJyZXZpYXRlCgkhICB0ZWgJCSB0aGUKCQlMYXN0IHNldCBmcm9tIC9ob21lL2FiY2QvdmltL2FiYnIudmltCgpTZWUgfDp2ZXJib3NlLWNtZHwgZm9yIG1vcmUgaW5mb3JtYXRpb24uCgo6YWJbYnJldmlhdGVdIHtsaHN9CWxpc3QgdGhlIGFiYnJldmlhdGlvbnMgdGhhdCBzdGFydCB3aXRoIHtsaHN9CgkJCVlvdSBtYXkgbmVlZCB0byBpbnNlcnQgYSBDVFJMLVYgKHR5cGUgaXQgdHdpY2UpIHRvCgkJCWF2b2lkIHRoYXQgYSB0eXBlZCB7bGhzfSBpcyBleHBhbmRlZCwgc2luY2UKCQkJY29tbWFuZC1saW5lIGFiYnJldmlhdGlvbnMgYXBwbHkgaGVyZS4KCjphYlticmV2aWF0ZV0gWzxleHByPl0ge2xoc30ge3Joc30KCQkJYWRkIGFiYnJldmlhdGlvbiBmb3Ige2xoc30gdG8ge3Joc30uICBJZiB7bGhzfSBhbHJlYWR5CgkJCWV4aXN0ZWQgaXQgaXMgcmVwbGFjZWQgd2l0aCB0aGUgbmV3IHtyaHN9LiAge3Joc30gbWF5CgkJCWNvbnRhaW4gc3BhY2VzLgoJCQlTZWUgfDptYXAtPGV4cHI+fCBmb3IgdGhlIG9wdGlvbmFsIDxleHByPiBhcmd1bWVudC4KCgkJCQkJCSo6dW5hKiAqOnVuYWJicmV2aWF0ZSoKOnVuYVtiYnJldmlhdGVdIHtsaHN9CVJlbW92ZSBhYmJyZXZpYXRpb24gZm9yIHtsaHN9IGZyb20gdGhlIGxpc3QuICBJZiBub25lCgkJCWlzIGZvdW5kLCByZW1vdmUgYWJicmV2aWF0aW9ucyBpbiB3aGljaCB7bGhzfSBtYXRjaGVzCgkJCXdpdGggdGhlIHtyaHN9LiAgVGhpcyBpcyBkb25lIHNvIHRoYXQgeW91IGNhbiBldmVuCgkJCXJlbW92ZSBhYmJyZXZpYXRpb25zIGFmdGVyIGV4cGFuc2lvbi4gIFRvIGF2b2lkCgkJCWV4cGFuc2lvbiBpbnNlcnQgYSBDVFJMLVYgKHR5cGUgaXQgdHdpY2UpLgoKCQkJCQkJKjpub3JlYSogKjpub3JlYWJicmV2Kgo6bm9yZWFbYmJyZXZdIFs8ZXhwcj5dIFtsaHNdIFtyaHNdCgkJCXNhbWUgYXMgIjphYiIsIGJ1dCBubyByZW1hcHBpbmcgZm9yIHRoaXMge3Joc30ge25vdAoJCQlpbiBWaX0KCgkJCQkJCSo6Y2EqICo6Y2FiYnJldioKOmNhW2JicmV2XSBbPGV4cHI+XSBbbGhzXSBbcmhzXQoJCQlzYW1lIGFzICI6YWIiLCBidXQgZm9yIENvbW1hbmQtbGluZSBtb2RlIG9ubHkuICB7bm90CgkJCWluIFZpfQoKCQkJCQkJKjpjdW5hKiAqOmN1bmFiYnJldioKOmN1bmFbYmJyZXZdIHtsaHN9CXNhbWUgYXMgIjp1bmEiLCBidXQgZm9yIENvbW1hbmQtbGluZSBtb2RlIG9ubHkuICB7bm90CgkJCWluIFZpfQoKCQkJCQkJKjpjbm9yZWEqICo6Y25vcmVhYmJyZXYqCjpjbm9yZWFbYmJyZXZdIFs8ZXhwcj5dIFtsaHNdIFtyaHNdCgkJCXNhbWUgYXMgIjphYiIsIGJ1dCBmb3IgQ29tbWFuZC1saW5lIG1vZGUgb25seSBhbmQgbm8KCQkJcmVtYXBwaW5nIGZvciB0aGlzIHtyaHN9IHtub3QgaW4gVml9CgoJCQkJCQkqOmlhKiAqOmlhYmJyZXYqCjppYVtiYnJldl0gWzxleHByPl0gW2xoc10gW3Joc10KCQkJc2FtZSBhcyAiOmFiIiwgYnV0IGZvciBJbnNlcnQgbW9kZSBvbmx5LiAge25vdCBpbiBWaX0KCgkJCQkJCSo6aXVuYSogKjppdW5hYmJyZXYqCjppdW5hW2JicmV2XSB7bGhzfQlzYW1lIGFzICI6dW5hIiwgYnV0IGZvciBpbnNlcnQgbW9kZSBvbmx5LiAge25vdCBpbgoJCQlWaX0KCgkJCQkJCSo6aW5vcmVhKiAqOmlub3JlYWJicmV2Kgo6aW5vcmVhW2JicmV2XSBbPGV4cHI+XSBbbGhzXSBbcmhzXQoJCQlzYW1lIGFzICI6YWIiLCBidXQgZm9yIEluc2VydCBtb2RlIG9ubHkgYW5kIG5vCgkJCXJlbWFwcGluZyBmb3IgdGhpcyB7cmhzfSB7bm90IGluIFZpfQoKCQkJCQkJCSo6YWJjKiAqOmFiY2xlYXIqCjphYmNbbGVhcl0JCVJlbW92ZSBhbGwgYWJicmV2aWF0aW9ucy4gIHtub3QgaW4gVml9CgoJCQkJCQkJKjppYWJjKiAqOmlhYmNsZWFyKgo6aWFiY1tsZWFyXQkJUmVtb3ZlIGFsbCBhYmJyZXZpYXRpb25zIGZvciBJbnNlcnQgbW9kZS4gIHtub3QgaW4gVml9CgoJCQkJCQkJKjpjYWJjKiAqOmNhYmNsZWFyKgo6Y2FiY1tsZWFyXQkJUmVtb3ZlIGFsbCBhYmJyZXZpYXRpb25zIGZvciBDb21tYW5kLWxpbmUgbW9kZS4gIHtub3QKCQkJaW4gVml9CgoJCQkJCQkJKnVzaW5nX0NUUkwtVioKSXQgaXMgcG9zc2libGUgdG8gdXNlIHNwZWNpYWwgY2hhcmFjdGVycyBpbiB0aGUgcmhzIG9mIGFuIGFiYnJldmlhdGlvbi4KQ1RSTC1WIGhhcyB0byBiZSB1c2VkIHRvIGF2b2lkIHRoZSBzcGVjaWFsIG1lYW5pbmcgb2YgbW9zdCBub24gcHJpbnRhYmxlCmNoYXJhY3RlcnMuICBIb3cgbWFueSBDVFJMLVZzIG5lZWQgdG8gYmUgdHlwZWQgZGVwZW5kcyBvbiBob3cgeW91IGVudGVyIHRoZQphYmJyZXZpYXRpb24uICBUaGlzIGFsc28gYXBwbGllcyB0byBtYXBwaW5ncy4gIExldCdzIHVzZSBhbiBleGFtcGxlIGhlcmUuCgpTdXBwb3NlIHlvdSB3YW50IHRvIGFiYnJldmlhdGUgImVzYyIgdG8gZW50ZXIgYW4gPEVzYz4gY2hhcmFjdGVyLiAgV2hlbiB5b3UKdHlwZSB0aGUgIjphYiIgY29tbWFuZCBpbiBWaW0sIHlvdSBoYXZlIHRvIGVudGVyIHRoaXM6IChoZXJlIF5WIGlzIGEgQ1RSTC1WCmFuZCBeWyBpcyA8RXNjPikKCllvdSB0eXBlOiAgIGFiIGVzYyBeVl5WXlZeVl5WXlsKCglBbGwga2V5Ym9hcmQgaW5wdXQgaXMgc3ViamVjdGVkIHRvIF5WIHF1b3RlIGludGVycHJldGF0aW9uLCBzbwoJdGhlIGZpcnN0LCB0aGlyZCwgYW5kIGZpZnRoIF5WICBjaGFyYWN0ZXJzIHNpbXBseSBhbGxvdyB0aGUgc2Vjb25kLAoJYW5kIGZvdXJ0aCBeVnMsIGFuZCB0aGUgXlssIHRvIGJlIGVudGVyZWQgaW50byB0aGUgY29tbWFuZC1saW5lLgoKWW91IHNlZTogICAgYWIgZXNjIF5WXlZeWwoKCVRoZSBjb21tYW5kLWxpbmUgY29udGFpbnMgdHdvIGFjdHVhbCBeVnMgYmVmb3JlIHRoZSBeWy4gIFRoaXMgaXMKCWhvdyBpdCBzaG91bGQgYXBwZWFyIGluIHlvdXIgLmV4cmMgZmlsZSwgaWYgeW91IGNob29zZSB0byBnbyB0aGF0Cglyb3V0ZS4gIFRoZSBmaXJzdCBeViBpcyB0aGVyZSB0byBxdW90ZSB0aGUgc2Vjb25kIF5WOyB0aGUgOmFiCgljb21tYW5kIHVzZXMgXlYgYXMgaXRzIG93biBxdW90ZSBjaGFyYWN0ZXIsIHNvIHlvdSBjYW4gaW5jbHVkZSBxdW90ZWQKCXdoaXRlc3BhY2Ugb3IgdGhlIHwgY2hhcmFjdGVyIGluIHRoZSBhYmJyZXZpYXRpb24uICBUaGUgOmFiIGNvbW1hbmQKCWRvZXNuJ3QgZG8gYW55dGhpbmcgc3BlY2lhbCB3aXRoIHRoZSBeWyBjaGFyYWN0ZXIsIHNvIGl0IGRvZXNuJ3QgbmVlZAoJdG8gYmUgcXVvdGVkLiAgKEFsdGhvdWdoIHF1b3RpbmcgaXNuJ3QgaGFybWZ1bDsgdGhhdCdzIHdoeSB0eXBpbmcgNwoJW2J1dCBub3QgOCFdIF5WcyB3b3Jrcy4pCgpTdG9yZWQgYXM6ICBlc2MgICAgIF5WXlsKCglBZnRlciBwYXJzaW5nLCB0aGUgYWJicmV2aWF0aW9uJ3Mgc2hvcnQgZm9ybSAoImVzYyIpIGFuZCBsb25nIGZvcm0KCSh0aGUgdHdvIGNoYXJhY3RlcnMgIl5WXlsiKSBhcmUgc3RvcmVkIGluIHRoZSBhYmJyZXZpYXRpb24gdGFibGUuCglJZiB5b3UgZ2l2ZSB0aGUgOmFiIGNvbW1hbmQgd2l0aCBubyBhcmd1bWVudHMsIHRoaXMgaXMgaG93IHRoZQoJYWJicmV2aWF0aW9uIHdpbGwgYmUgZGlzcGxheWVkLgoKCUxhdGVyLCB3aGVuIHRoZSBhYmJyZXZpYXRpb24gaXMgZXhwYW5kZWQgYmVjYXVzZSB0aGUgdXNlciB0eXBlZCBpbgoJdGhlIHdvcmQgImVzYyIsIHRoZSBsb25nIGZvcm0gaXMgc3ViamVjdGVkIHRvIHRoZSBzYW1lIHR5cGUgb2YKCV5WIGludGVycHJldGF0aW9uIGFzIGtleWJvYXJkIGlucHV0LiAgU28gdGhlIF5WIHByb3RlY3RzIHRoZSBeWwoJY2hhcmFjdGVyIGZyb20gYmVpbmcgaW50ZXJwcmV0ZWQgYXMgdGhlICJleGl0IEluc2VydCBtb2RlIiBjaGFyYWN0ZXIuCglJbnN0ZWFkLCB0aGUgXlsgaXMgaW5zZXJ0ZWQgaW50byB0aGUgdGV4dC4KCkV4cGFuZHMgdG86IF5bCgpbZXhhbXBsZSBnaXZlbiBieSBTdGV2ZSBLaXJrZW5kYWxsXQoKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CjMuIExvY2FsIG1hcHBpbmdzIGFuZCBmdW5jdGlvbnMJCQkJKnNjcmlwdC1sb2NhbCoKCldoZW4gdXNpbmcgc2V2ZXJhbCBWaW0gc2NyaXB0IGZpbGVzLCB0aGVyZSBpcyB0aGUgZGFuZ2VyIHRoYXQgbWFwcGluZ3MgYW5kCmZ1bmN0aW9ucyB1c2VkIGluIG9uZSBzY3JpcHQgdXNlIHRoZSBzYW1lIG5hbWUgYXMgaW4gb3RoZXIgc2NyaXB0cy4gIFRvIGF2b2lkCnRoaXMsIHRoZXkgY2FuIGJlIG1hZGUgbG9jYWwgdG8gdGhlIHNjcmlwdC4KCgkJCQkJCSo8U0lEPiogKjxTTlI+KiAqRTgxKgpUaGUgc3RyaW5nICI8U0lEPiIgY2FuIGJlIHVzZWQgaW4gYSBtYXBwaW5nIG9yIG1lbnUuICBUaGlzIHJlcXVpcmVzIHRoYXQgdGhlCic8JyBmbGFnIGlzIG5vdCBwcmVzZW50IGluICdjcG9wdGlvbnMnLgogICBXaGVuIGV4ZWN1dGluZyB0aGUgbWFwIGNvbW1hbmQsIFZpbSB3aWxsIHJlcGxhY2UgIjxTSUQ+IiB3aXRoIHRoZSBzcGVjaWFsCmtleSBjb2RlIDxTTlI+LCBmb2xsb3dlZCBieSBhIG51bWJlciB0aGF0J3MgdW5pcXVlIGZvciB0aGUgc2NyaXB0LCBhbmQgYW4KdW5kZXJzY29yZS4gIEV4YW1wbGU6ID4KCTptYXAgPFNJRD5BZGQKY291bGQgZGVmaW5lIGEgbWFwcGluZyAiPFNOUj4yM19BZGQiLgoKV2hlbiBkZWZpbmluZyBhIGZ1bmN0aW9uIGluIGEgc2NyaXB0LCAiczoiIGNhbiBiZSBwcmVwZW5kZWQgdG8gdGhlIG5hbWUgdG8KbWFrZSBpdCBsb2NhbCB0byB0aGUgc2NyaXB0LiAgQnV0IHdoZW4gYSBtYXBwaW5nIGlzIGV4ZWN1dGVkIGZyb20gb3V0c2lkZSBvZgp0aGUgc2NyaXB0LCBpdCBkb2Vzbid0IGtub3cgaW4gd2hpY2ggc2NyaXB0IHRoZSBmdW5jdGlvbiB3YXMgZGVmaW5lZC4gIFRvCmF2b2lkIHRoaXMgcHJvYmxlbSwgdXNlICI8U0lEPiIgaW5zdGVhZCBvZiAiczoiLiAgVGhlIHNhbWUgdHJhbnNsYXRpb24gaXMgZG9uZQphcyBmb3IgbWFwcGluZ3MuICBUaGlzIG1ha2VzIGl0IHBvc3NpYmxlIHRvIGRlZmluZSBhIGNhbGwgdG8gdGhlIGZ1bmN0aW9uIGluCmEgbWFwcGluZy4KCldoZW4gYSBsb2NhbCBmdW5jdGlvbiBpcyBleGVjdXRlZCwgaXQgcnVucyBpbiB0aGUgY29udGV4dCBvZiB0aGUgc2NyaXB0IGl0IHdhcwpkZWZpbmVkIGluLiAgVGhpcyBtZWFucyB0aGF0IG5ldyBmdW5jdGlvbnMgYW5kIG1hcHBpbmdzIGl0IGRlZmluZXMgY2FuIGFsc28KdXNlICJzOiIgb3IgIjxTSUQ+IiBhbmQgaXQgd2lsbCB1c2UgdGhlIHNhbWUgdW5pcXVlIG51bWJlciBhcyB3aGVuIHRoZQpmdW5jdGlvbiBpdHNlbGYgd2FzIGRlZmluZWQuICBBbHNvLCB0aGUgInM6dmFyIiBsb2NhbCBzY3JpcHQgdmFyaWFibGVzIGNhbiBiZQp1c2VkLgoKV2hlbiBleGVjdXRpbmcgYW4gYXV0b2NvbW1hbmQgb3IgYSB1c2VyIGNvbW1hbmQsIGl0IHdpbGwgcnVuIGluIHRoZSBjb250ZXh0IG9mCnRoZSBzY3JpcHQgaXQgd2FzIGRlZmluZWQgaW4uICBUaGlzIG1ha2VzIGl0IHBvc3NpYmxlIHRoYXQgdGhlIGNvbW1hbmQgY2FsbHMgYQpsb2NhbCBmdW5jdGlvbiBvciB1c2VzIGEgbG9jYWwgbWFwcGluZy4KCk90aGVyd2lzZSwgdXNpbmcgIjxTSUQ+IiBvdXRzaWRlIG9mIGEgc2NyaXB0IGNvbnRleHQgaXMgYW4gZXJyb3IuCgpJZiB5b3UgbmVlZCB0byBnZXQgdGhlIHNjcmlwdCBudW1iZXIgdG8gdXNlIGluIGEgY29tcGxpY2F0ZWQgc2NyaXB0LCB5b3UgY2FuCnVzZSB0aGlzIGZ1bmN0aW9uOiA+CglmdW5jdGlvbiBzOlNJRCgpCgkgIHJldHVybiBtYXRjaHN0cihleHBhbmQoJzxzZmlsZT4nKSwgJzxTTlI+XHpzXGRcK1x6ZV9TSUQkJykKCWVuZGZ1bgoKVGhlICI8U05SPiIgd2lsbCBiZSBzaG93biB3aGVuIGxpc3RpbmcgZnVuY3Rpb25zIGFuZCBtYXBwaW5ncy4gIFRoaXMgaXMgdXNlZnVsCnRvIGZpbmQgb3V0IHdoYXQgdGhleSBhcmUgZGVmaW5lZCB0by4KClRoZSB8OnNjcmlwdG5hbWVzfCBjb21tYW5kIGNhbiBiZSB1c2VkIHRvIHNlZSB3aGljaCBzY3JpcHRzIGhhdmUgYmVlbiBzb3VyY2VkCmFuZCB3aGF0IHRoZWlyIDxTTlI+IG51bWJlciBpcy4KClRoaXMgaXMgYWxsIHtub3QgaW4gVml9IGFuZCB7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZXZhbHwKZmVhdHVyZX0uCgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KNC4gVXNlci1kZWZpbmVkIGNvbW1hbmRzCQkJCSp1c2VyLWNvbW1hbmRzKgoKSXQgaXMgcG9zc2libGUgdG8gZGVmaW5lIHlvdXIgb3duIEV4IGNvbW1hbmRzLiAgQSB1c2VyLWRlZmluZWQgY29tbWFuZCBjYW4gYWN0Cmp1c3QgbGlrZSBhIGJ1aWx0LWluIGNvbW1hbmQgKGl0IGNhbiBoYXZlIGEgcmFuZ2Ugb3IgYXJndW1lbnRzLCBhcmd1bWVudHMgY2FuCmJlIGNvbXBsZXRlZCBhcyBmaWxlbmFtZXMgb3IgYnVmZmVyIG5hbWVzLCBldGMpLCBleGNlcHQgdGhhdCB3aGVuIHRoZSBjb21tYW5kCmlzIGV4ZWN1dGVkLCBpdCBpcyB0cmFuc2Zvcm1lZCBpbnRvIGEgbm9ybWFsIEV4IGNvbW1hbmQgYW5kIHRoZW4gZXhlY3V0ZWQuCgpGb3Igc3RhcnRlcnM6IFNlZSBzZWN0aW9uIHw0MC4yfCBpbiB0aGUgdXNlciBtYW51YWwuCgoJCQkJCSpFMTgzKiAqRTg0MSogKnVzZXItY21kLWFtYmlndW91cyoKQWxsIHVzZXIgZGVmaW5lZCBjb21tYW5kcyBtdXN0IHN0YXJ0IHdpdGggYW4gdXBwZXJjYXNlIGxldHRlciwgdG8gYXZvaWQKY29uZnVzaW9uIHdpdGggYnVpbHRpbiBjb21tYW5kcy4gIEV4Y2VwdGlvbnMgYXJlIHRoZXNlIGJ1aWx0aW4gY29tbWFuZHM6Cgk6TmV4dAoJOlgKVGhleSBjYW5ub3QgYmUgdXNlZCBmb3IgYSB1c2VyIGRlZmluZWQgY29tbWFuZC4gICI6UHJpbnQiIGlzIGFsc28gYW4gZXhpc3RpbmcKY29tbWFuZCwgYnV0IGl0IGlzIGRlcHJlY2F0ZWQgYW5kIGNhbiBiZSBvdmVycnVsZWQuCgpUaGUgb3RoZXIgY2hhcmFjdGVycyBvZiB0aGUgdXNlciBjb21tYW5kIGNhbiBiZSB1cHBlcmNhc2UgbGV0dGVycywgbG93ZXJjYXNlCmxldHRlcnMgb3IgZGlnaXRzLiAgV2hlbiB1c2luZyBkaWdpdHMsIG5vdGUgdGhhdCBvdGhlciBjb21tYW5kcyB0aGF0IHRha2UgYQpudW1lcmljIGFyZ3VtZW50IG1heSBiZWNvbWUgYW1iaWd1b3VzLiAgRm9yIGV4YW1wbGUsIHRoZSBjb21tYW5kICI6Q2MyIiBjb3VsZApiZSB0aGUgdXNlciBjb21tYW5kICI6Q2MyIiB3aXRob3V0IGFuIGFyZ3VtZW50LCBvciB0aGUgY29tbWFuZCAiOkNjIiB3aXRoCmFyZ3VtZW50ICIyIi4gIEl0IGlzIGFkdmlzZWQgdG8gcHV0IGEgc3BhY2UgYmV0d2VlbiB0aGUgY29tbWFuZCBuYW1lIGFuZCB0aGUKYXJndW1lbnQgdG8gYXZvaWQgdGhlc2UgcHJvYmxlbXMuCgpXaGVuIHVzaW5nIGEgdXNlci1kZWZpbmVkIGNvbW1hbmQsIHRoZSBjb21tYW5kIGNhbiBiZSBhYmJyZXZpYXRlZC4gIEhvd2V2ZXIsIGlmCmFuIGFiYnJldmlhdGlvbiBpcyBub3QgdW5pcXVlLCBhbiBlcnJvciB3aWxsIGJlIGlzc3VlZC4gIEZ1cnRoZXJtb3JlLCBhCmJ1aWx0LWluIGNvbW1hbmQgd2lsbCBhbHdheXMgdGFrZSBwcmVjZWRlbmNlLgoKRXhhbXBsZTogPgoJOmNvbW1hbmQgUmVuYW1lIC4uLgoJOmNvbW1hbmQgUmVudW1iZXIgLi4uCgk6UmVuYQkJCQkiIE1lYW5zICJSZW5hbWUiCgk6UmVudQkJCQkiIE1lYW5zICJSZW51bWJlciIKCTpSZW4JCQkJIiBFcnJvciAtIGFtYmlndW91cwoJOmNvbW1hbmQgUGFzdGUgLi4uCgk6UAkJCQkiIFRoZSBidWlsdC1pbiA6UHJpbnQKCkl0IGlzIHJlY29tbWVuZGVkIHRoYXQgZnVsbCBuYW1lcyBmb3IgdXNlci1kZWZpbmVkIGNvbW1hbmRzIGFyZSB1c2VkIGluCnNjcmlwdHMuCgo6Y29tW21hbmRdCQkJCQkJKjpjb20qICo6Y29tbWFuZCoKCQkJTGlzdCBhbGwgdXNlci1kZWZpbmVkIGNvbW1hbmRzLiAgV2hlbiBsaXN0aW5nIGNvbW1hbmRzLAoJCQl0aGUgY2hhcmFjdGVycyBpbiB0aGUgZmlyc3QgdHdvIGNvbHVtbnMgYXJlCgkJCSAgICAhCUNvbW1hbmQgaGFzIHRoZSAtYmFuZyBhdHRyaWJ1dGUKCQkJICAgICIJQ29tbWFuZCBoYXMgdGhlIC1yZWdpc3RlciBhdHRyaWJ1dGUKCQkJICAgIGIJQ29tbWFuZCBpcyBsb2NhbCB0byBjdXJyZW50IGJ1ZmZlcgoJCQkoc2VlIGJlbG93IGZvciBkZXRhaWxzIG9uIGF0dHJpYnV0ZXMpCgo6Y29tW21hbmRdIHtjbWR9CUxpc3QgdGhlIHVzZXItZGVmaW5lZCBjb21tYW5kcyB0aGF0IHN0YXJ0IHdpdGgge2NtZH0KCgkJCQkJCQkqOmNvbW1hbmQtdmVyYm9zZSoKV2hlbiAndmVyYm9zZScgaXMgbm9uLXplcm8sIGxpc3RpbmcgYSBjb21tYW5kIHdpbGwgYWxzbyBkaXNwbGF5IHdoZXJlIGl0IHdhcwpsYXN0IGRlZmluZWQuIEV4YW1wbGU6ID4KCiAgICA6dmVyYm9zZSBjb21tYW5kIFRPaHRtbAo8CU5hbWUJICAgIEFyZ3MgUmFuZ2UgQ29tcGxldGUgIERlZmluaXRpb24gfgoJVE9odG1sCSAgICAwCSAlCQkgOmNhbGwgQ29udmVydDJIVE1MKDxsaW5lMT4sIDxsaW5lMj4pIH4KCSAgICBMYXN0IHNldCBmcm9tIC91c3Ivc2hhcmUvdmltL3ZpbS03LjAvcGx1Z2luL3RvaHRtbC52aW0gfgoKU2VlIHw6dmVyYm9zZS1jbWR8IGZvciBtb3JlIGluZm9ybWF0aW9uLgoKCQkJCQkJCSpFMTc0KiAqRTE4MioKOmNvbVttYW5kXVshXSBbe2F0dHJ9Li4uXSB7Y21kfSB7cmVwfQoJCQlEZWZpbmUgYSB1c2VyIGNvbW1hbmQuICBUaGUgbmFtZSBvZiB0aGUgY29tbWFuZCBpcwoJCQl7Y21kfSBhbmQgaXRzIHJlcGxhY2VtZW50IHRleHQgaXMge3JlcH0uICBUaGUgY29tbWFuZCdzCgkJCWF0dHJpYnV0ZXMgKHNlZSBiZWxvdykgYXJlIHthdHRyfS4gIElmIHRoZSBjb21tYW5kCgkJCWFscmVhZHkgZXhpc3RzLCBhbiBlcnJvciBpcyByZXBvcnRlZCwgdW5sZXNzIGEgISBpcwoJCQlzcGVjaWZpZWQsIGluIHdoaWNoIGNhc2UgdGhlIGNvbW1hbmQgaXMgcmVkZWZpbmVkLgoKOmRlbGNbb21tYW5kXSB7Y21kfQkJCQkqOmRlbGMqICo6ZGVsY29tbWFuZCogKkUxODQqCgkJCURlbGV0ZSB0aGUgdXNlci1kZWZpbmVkIGNvbW1hbmQge2NtZH0uCgo6Y29tY1tsZWFyXQkJCQkJCSo6Y29tYyogKjpjb21jbGVhcioKCQkJRGVsZXRlIGFsbCB1c2VyLWRlZmluZWQgY29tbWFuZHMuCgpDb21tYW5kIGF0dHJpYnV0ZXMKClVzZXItZGVmaW5lZCBjb21tYW5kcyBhcmUgdHJlYXRlZCBieSBWaW0ganVzdCBsaWtlIGFueSBvdGhlciBFeCBjb21tYW5kcy4gIFRoZXkKY2FuIGhhdmUgYXJndW1lbnRzLCBvciBoYXZlIGEgcmFuZ2Ugc3BlY2lmaWVkLiAgQXJndW1lbnRzIGFyZSBzdWJqZWN0IHRvCmNvbXBsZXRpb24gYXMgZmlsZW5hbWVzLCBidWZmZXJzLCBldGMuICBFeGFjdGx5IGhvdyB0aGlzIHdvcmtzIGRlcGVuZHMgdXBvbiB0aGUKY29tbWFuZCdzIGF0dHJpYnV0ZXMsIHdoaWNoIGFyZSBzcGVjaWZpZWQgd2hlbiB0aGUgY29tbWFuZCBpcyBkZWZpbmVkLgoKVGhlcmUgYXJlIGEgbnVtYmVyIG9mIGF0dHJpYnV0ZXMsIHNwbGl0IGludG8gZm91ciBjYXRlZ29yaWVzOiBhcmd1bWVudApoYW5kbGluZywgY29tcGxldGlvbiBiZWhhdmlvciwgcmFuZ2UgaGFuZGxpbmcsIGFuZCBzcGVjaWFsIGNhc2VzLiAgVGhlCmF0dHJpYnV0ZXMgYXJlIGRlc2NyaWJlZCBiZWxvdywgYnkgY2F0ZWdvcnkuCgpBcmd1bWVudCBoYW5kbGluZwkJCQkqRTE3NSogKkUxNzYqICo6Y29tbWFuZC1uYXJncyoKCkJ5IGRlZmF1bHQsIGEgdXNlciBkZWZpbmVkIGNvbW1hbmQgd2lsbCB0YWtlIG5vIGFyZ3VtZW50cyAoYW5kIGFuIGVycm9yIGlzCnJlcG9ydGVkIGlmIGFueSBhcmUgc3VwcGxpZWQpLiAgSG93ZXZlciwgaXQgaXMgcG9zc2libGUgdG8gc3BlY2lmeSB0aGF0IHRoZQpjb21tYW5kIGNhbiB0YWtlIGFyZ3VtZW50cywgdXNpbmcgdGhlIC1uYXJncyBhdHRyaWJ1dGUuICBWYWxpZCBjYXNlcyBhcmU6CgoJLW5hcmdzPTAgICAgTm8gYXJndW1lbnRzIGFyZSBhbGxvd2VkICh0aGUgZGVmYXVsdCkKCS1uYXJncz0xICAgIEV4YWN0bHkgb25lIGFyZ3VtZW50IGlzIHJlcXVpcmUsIGl0IGluY2x1ZGVzIHNwYWNlcyAKCS1uYXJncz0qICAgIEFueSBudW1iZXIgb2YgYXJndW1lbnRzIGFyZSBhbGxvd2VkICgwLCAxLCBvciBtYW55KSwKCQkgICAgc2VwYXJhdGVkIGJ5IHdoaXRlIHNwYWNlCgktbmFyZ3M9PyAgICAwIG9yIDEgYXJndW1lbnRzIGFyZSBhbGxvd2VkCgktbmFyZ3M9KyAgICBBcmd1bWVudHMgbXVzdCBiZSBzdXBwbGllZCwgYnV0IGFueSBudW1iZXIgYXJlIGFsbG93ZWQKCkFyZ3VtZW50cyBhcmUgY29uc2lkZXJlZCB0byBiZSBzZXBhcmF0ZWQgYnkgKHVuZXNjYXBlZCkgc3BhY2VzIG9yIHRhYnMgaW4gdGhpcwpjb250ZXh0LCBleGNlcHQgd2hlbiB0aGVyZSBpcyBvbmUgYXJndW1lbnQsIHRoZW4gdGhlIHdoaXRlIHNwYWNlIGlzIHBhcnQgb2YKdGhlIGFyZ3VtZW50LgoKTm90ZSB0aGF0IGFyZ3VtZW50cyBhcmUgdXNlZCBhcyB0ZXh0LCBub3QgYXMgZXhwcmVzc2lvbnMuICBTcGVjaWZpY2FsbHksCiJzOnZhciIgd2lsbCB1c2UgdGhlIHNjcmlwdC1sb2NhbCB2YXJpYWJsZSBpbiB0aGUgc2NyaXB0IHdoZXJlIHRoZSBjb21tYW5kIHdhcwpkZWZpbmVkLCBub3Qgd2hlcmUgaXQgaXMgaW52b2tlZCEgIEV4YW1wbGU6CiAgICBzY3JpcHQxLnZpbTogPgoJOmxldCBzOmVycm9yID0gIk5vbmUiCgk6Y29tbWFuZCAtbmFyZ3M9MSBFcnJvciBlY2hvZXJyIDxhcmdzPgo8ICAgc2NyaXB0Mi52aW06ID4KCTpzb3VyY2Ugc2NyaXB0MS52aW0KCTpsZXQgczplcnJvciA9ICJXcm9uZyEiCgk6RXJyb3IgczplcnJvcgpFeGVjdXRpbmcgc2NyaXB0Mi52aW0gd2lsbCByZXN1bHQgaW4gIk5vbmUiIGJlaW5nIGVjaG9lZC4gIE5vdCB3aGF0IHlvdQppbnRlbmRlZCEgIENhbGxpbmcgYSBmdW5jdGlvbiBtYXkgYmUgYW4gYWx0ZXJuYXRpdmUuCgpDb21wbGV0aW9uIGJlaGF2aW9yCQkJCSo6Y29tbWFuZC1jb21wbGV0aW9uKiAqRTE3OSoKCQkJCQkqRTE4MCogKkUxODEqICo6Y29tbWFuZC1jb21wbGV0ZSoKQnkgZGVmYXVsdCwgdGhlIGFyZ3VtZW50cyBvZiB1c2VyIGRlZmluZWQgY29tbWFuZHMgZG8gbm90IHVuZGVyZ28gY29tcGxldGlvbi4KSG93ZXZlciwgYnkgc3BlY2lmeWluZyBvbmUgb3IgdGhlIG90aGVyIG9mIHRoZSBmb2xsb3dpbmcgYXR0cmlidXRlcywgYXJndW1lbnQKY29tcGxldGlvbiBjYW4gYmUgZW5hYmxlZDoKCgktY29tcGxldGU9YXVncm91cAlhdXRvY21kIGdyb3VwcwoJLWNvbXBsZXRlPWJ1ZmZlcglidWZmZXIgbmFtZXMKCS1jb21wbGV0ZT1jb21tYW5kCUV4IGNvbW1hbmQgKGFuZCBhcmd1bWVudHMpCgktY29tcGxldGU9Y3Njb3BlCXw6Y3Njb3BlfCBzdWJvcHRpb25zCgktY29tcGxldGU9ZGlyCQlkaXJlY3RvcnkgbmFtZXMKCS1jb21wbGV0ZT1lbnZpcm9ubWVudAllbnZpcm9ubWVudCB2YXJpYWJsZSBuYW1lcwoJLWNvbXBsZXRlPWV2ZW50CQlhdXRvY29tbWFuZCBldmVudHMKCS1jb21wbGV0ZT1leHByZXNzaW9uCVZpbSBleHByZXNzaW9uCgktY29tcGxldGU9ZmlsZQkJZmlsZSBhbmQgZGlyZWN0b3J5IG5hbWVzCgktY29tcGxldGU9ZmlsZXR5cGUJZmlsZXR5cGUgbmFtZXMgfCdmaWxldHlwZSd8CgktY29tcGxldGU9ZnVuY3Rpb24JZnVuY3Rpb24gbmFtZQoJLWNvbXBsZXRlPWhlbHAJCWhlbHAgc3ViamVjdHMKCS1jb21wbGV0ZT1oaWdobGlnaHQJaGlnaGxpZ2h0IGdyb3VwcwoJLWNvbXBsZXRlPW1hcHBpbmcJbWFwcGluZyBuYW1lCgktY29tcGxldGU9bWVudQkJbWVudXMKCS1jb21wbGV0ZT1vcHRpb24Jb3B0aW9ucwoJLWNvbXBsZXRlPXNoZWxsY21kCVNoZWxsIGNvbW1hbmQKCS1jb21wbGV0ZT1zaWduCQl8OnNpZ258IHN1Ym9wdGlvbnMKCS1jb21wbGV0ZT1zeW50YXgJc3ludGF4IGZpbGUgbmFtZXMgfCdzeW50YXgnfAoJLWNvbXBsZXRlPXRhZwkJdGFncwoJLWNvbXBsZXRlPXRhZ19saXN0ZmlsZXMJdGFncywgZmlsZSBuYW1lcyBhcmUgc2hvd24gd2hlbiBDVFJMLUQgaXMgaGl0CgktY29tcGxldGU9dmFyCQl1c2VyIHZhcmlhYmxlcwoJLWNvbXBsZXRlPWN1c3RvbSx7ZnVuY30gY3VzdG9tIGNvbXBsZXRpb24sIGRlZmluZWQgdmlhIHtmdW5jfQoJLWNvbXBsZXRlPWN1c3RvbWxpc3Qse2Z1bmN9IGN1c3RvbSBjb21wbGV0aW9uLCBkZWZpbmVkIHZpYSB7ZnVuY30KCgpDdXN0b20gY29tcGxldGlvbgkJCSo6Y29tbWFuZC1jb21wbGV0aW9uLWN1c3RvbSoKCQkJCQkqOmNvbW1hbmQtY29tcGxldGlvbi1jdXN0b21saXN0KgoJCQkJCSpFNDY3KiAqRTQ2OCoKSXQgaXMgcG9zc2libGUgdG8gZGVmaW5lIGN1c3RvbWl6ZWQgY29tcGxldGlvbiBzY2hlbWVzIHZpYSB0aGUgImN1c3RvbSx7ZnVuY30iCm9yIHRoZSAiY3VzdG9tbGlzdCx7ZnVuY30iIGNvbXBsZXRpb24gYXJndW1lbnQuICBUaGUge2Z1bmN9IHBhcnQgc2hvdWxkIGJlIGEKZnVuY3Rpb24gd2l0aCB0aGUgZm9sbG93aW5nIHNpZ25hdHVyZTogPgoKCTpmdW5jdGlvbiB7ZnVuY30oQXJnTGVhZCwgQ21kTGluZSwgQ3Vyc29yUG9zKQoKVGhlIGZ1bmN0aW9uIG5lZWQgbm90IHVzZSBhbGwgdGhlc2UgYXJndW1lbnRzLiBUaGUgZnVuY3Rpb24gc2hvdWxkIHByb3ZpZGUgdGhlCmNvbXBsZXRpb24gY2FuZGlkYXRlcyBhcyB0aGUgcmV0dXJuIHZhbHVlLgoKRm9yIHRoZSAiY3VzdG9tIiBhcmd1bWVudCwgdGhlIGZ1bmN0aW9uIHNob3VsZCByZXR1cm4gdGhlIGNvbXBsZXRpb24KY2FuZGlkYXRlcyBvbmUgcGVyIGxpbmUgaW4gYSBuZXdsaW5lIHNlcGFyYXRlZCBzdHJpbmcuCgpGb3IgdGhlICJjdXN0b21saXN0IiBhcmd1bWVudCwgdGhlIGZ1bmN0aW9uIHNob3VsZCByZXR1cm4gdGhlIGNvbXBsZXRpb24KY2FuZGlkYXRlcyBhcyBhIFZpbSBMaXN0LiAgTm9uLXN0cmluZyBpdGVtcyBpbiB0aGUgbGlzdCBhcmUgaWdub3JlZC4KClRoZSBmdW5jdGlvbiBhcmd1bWVudHMgYXJlOgoJQXJnTGVhZAkJdGhlIGxlYWRpbmcgcG9ydGlvbiBvZiB0aGUgYXJndW1lbnQgY3VycmVudGx5IGJlaW5nCgkJCWNvbXBsZXRlZCBvbgoJQ21kTGluZQkJdGhlIGVudGlyZSBjb21tYW5kIGxpbmUKCUN1cnNvclBvcwl0aGUgY3Vyc29yIHBvc2l0aW9uIGluIGl0IChieXRlIGluZGV4KQpUaGUgZnVuY3Rpb24gbWF5IHVzZSB0aGVzZSBmb3IgZGV0ZXJtaW5pbmcgY29udGV4dC4gIEZvciB0aGUgImN1c3RvbSIKYXJndW1lbnQsIGl0IGlzIG5vdCBuZWNlc3NhcnkgdG8gZmlsdGVyIGNhbmRpZGF0ZXMgYWdhaW5zdCB0aGUgKGltcGxpY2l0CnBhdHRlcm4gaW4pIEFyZ0xlYWQuICBWaW0gd2lsbCBmaWx0ZXIgdGhlIGNhbmRpZGF0ZXMgd2l0aCBpdHMgcmVnZXhwIGVuZ2luZQphZnRlciBmdW5jdGlvbiByZXR1cm4sIGFuZCB0aGlzIGlzIHByb2JhYmx5IG1vcmUgZWZmaWNpZW50IGluIG1vc3QgY2FzZXMuIEZvcgp0aGUgImN1c3RvbWxpc3QiIGFyZ3VtZW50LCBWaW0gd2lsbCBub3QgZmlsdGVyIHRoZSByZXR1cm5lZCBjb21wbGV0aW9uCmNhbmRpZGF0ZXMgYW5kIHRoZSB1c2VyIHN1cHBsaWVkIGZ1bmN0aW9uIHNob3VsZCBmaWx0ZXIgdGhlIGNhbmRpZGF0ZXMuCgpUaGUgZm9sbG93aW5nIGV4YW1wbGUgbGlzdHMgdXNlciBuYW1lcyB0byBhIEZpbmdlciBjb21tYW5kID4KICAgIDpjb20gLWNvbXBsZXRlPWN1c3RvbSxMaXN0VXNlcnMgLW5hcmdzPTEgRmluZ2VyICFmaW5nZXIgPGFyZ3M+CiAgICA6ZnVuIExpc3RVc2VycyhBLEwsUCkKICAgIDogICAgcmV0dXJuIHN5c3RlbSgiY3V0IC1kOiAtZjEgL2V0Yy9wYXNzd2QiKQogICAgOmVuZGZ1bgoKVGhlIGZvbGxvd2luZyBleGFtcGxlIGNvbXBsZXRlcyBmaWxlbmFtZXMgZnJvbSB0aGUgZGlyZWN0b3JpZXMgc3BlY2lmaWVkIGluCnRoZSAncGF0aCcgb3B0aW9uOiA+CiAgICA6Y29tIC1uYXJncz0xIC1iYW5nIC1jb21wbGV0ZT1jdXN0b21saXN0LEVkaXRGaWxlQ29tcGxldGUKCQkJXCBFZGl0RmlsZSBlZGl0PGJhbmc+IDxhcmdzPgogICAgOmZ1biBFZGl0RmlsZUNvbXBsZXRlKEEsTCxQKQogICAgOiAgICByZXR1cm4gc3BsaXQoZ2xvYnBhdGgoJnBhdGgsIGE6QSksICJcbiIpCiAgICA6ZW5kZnVuCjwKVGhpcyBleGFtcGxlIGRvZXMgbm90IHdvcmsgZm9yIGZpbGUgbmFtZXMgd2l0aCBzcGFjZXMhCgoKUmFuZ2UgaGFuZGxpbmcJCQkJKkUxNzcqICpFMTc4KiAqOmNvbW1hbmQtcmFuZ2UqCgkJCQkJCQkqOmNvbW1hbmQtY291bnQqCkJ5IGRlZmF1bHQsIHVzZXItZGVmaW5lZCBjb21tYW5kcyBkbyBub3QgYWNjZXB0IGEgbGluZSBudW1iZXIgcmFuZ2UuICBIb3dldmVyLAppdCBpcyBwb3NzaWJsZSB0byBzcGVjaWZ5IHRoYXQgdGhlIGNvbW1hbmQgZG9lcyB0YWtlIGEgcmFuZ2UgKHRoZSAtcmFuZ2UKYXR0cmlidXRlKSwgb3IgdGhhdCBpdCB0YWtlcyBhbiBhcmJpdHJhcnkgY291bnQgdmFsdWUsIGVpdGhlciBpbiB0aGUgbGluZQpudW1iZXIgcG9zaXRpb24gKC1yYW5nZT1OLCBsaWtlIHRoZSB8OnNwbGl0fCBjb21tYW5kKSBvciBhcyBhICJjb3VudCIKYXJndW1lbnQgKC1jb3VudD1OLCBsaWtlIHRoZSB8Ok5leHR8IGNvbW1hbmQpLiAgVGhlIGNvdW50IHdpbGwgdGhlbiBiZQphdmFpbGFibGUgaW4gdGhlIGFyZ3VtZW50IHdpdGggfDxjb3VudD58LgoKUG9zc2libGUgYXR0cmlidXRlcyBhcmU6CgoJLXJhbmdlCSAgICBSYW5nZSBhbGxvd2VkLCBkZWZhdWx0IGlzIGN1cnJlbnQgbGluZQoJLXJhbmdlPSUgICAgUmFuZ2UgYWxsb3dlZCwgZGVmYXVsdCBpcyB3aG9sZSBmaWxlICgxLCQpCgktcmFuZ2U9TiAgICBBIGNvdW50IChkZWZhdWx0IE4pIHdoaWNoIGlzIHNwZWNpZmllZCBpbiB0aGUgbGluZQoJCSAgICBudW1iZXIgcG9zaXRpb24gKGxpa2UgfDpzcGxpdHwpOyBhbGxvd3MgZm9yIHplcm8gbGluZQoJCSAgICBudW1iZXIuCgktY291bnQ9TiAgICBBIGNvdW50IChkZWZhdWx0IE4pIHdoaWNoIGlzIHNwZWNpZmllZCBlaXRoZXIgaW4gdGhlIGxpbmUKCQkgICAgbnVtYmVyIHBvc2l0aW9uLCBvciBhcyBhbiBpbml0aWFsIGFyZ3VtZW50IChsaWtlIHw6TmV4dHwpLgoJCSAgICBTcGVjaWZ5aW5nIC1jb3VudCAod2l0aG91dCBhIGRlZmF1bHQpIGFjdHMgbGlrZSAtY291bnQ9MAoKTm90ZSB0aGF0IC1yYW5nZT1OIGFuZCAtY291bnQ9TiBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIC0gb25seSBvbmUgc2hvdWxkIGJlCnNwZWNpZmllZC4KClNwZWNpYWwgY2FzZXMJCQkJKjpjb21tYW5kLWJhbmcqICo6Y29tbWFuZC1iYXIqCgkJCQkJKjpjb21tYW5kLXJlZ2lzdGVyKiAqOmNvbW1hbmQtYnVmZmVyKgpUaGVyZSBhcmUgc29tZSBzcGVjaWFsIGNhc2VzIGFzIHdlbGw6CgoJLWJhbmcJICAgIFRoZSBjb21tYW5kIGNhbiB0YWtlIGEgISBtb2RpZmllciAobGlrZSA6cSBvciA6dykKCS1iYXIJICAgIFRoZSBjb21tYW5kIGNhbiBiZSBmb2xsb3dlZCBieSBhICJ8IiBhbmQgYW5vdGhlciBjb21tYW5kLgoJCSAgICBBICJ8IiBpbnNpZGUgdGhlIGNvbW1hbmQgYXJndW1lbnQgaXMgbm90IGFsbG93ZWQgdGhlbi4KCQkgICAgQWxzbyBjaGVja3MgZm9yIGEgIiB0byBzdGFydCBhIGNvbW1lbnQuCgktcmVnaXN0ZXIgICBUaGUgZmlyc3QgYXJndW1lbnQgdG8gdGhlIGNvbW1hbmQgY2FuIGJlIGFuIG9wdGlvbmFsCgkJICAgIHJlZ2lzdGVyIG5hbWUgKGxpa2UgOmRlbCwgOnB1dCwgOnlhbmspLgoJLWJ1ZmZlcgkgICAgVGhlIGNvbW1hbmQgd2lsbCBvbmx5IGJlIGF2YWlsYWJsZSBpbiB0aGUgY3VycmVudCBidWZmZXIuCgpJbiB0aGUgY2FzZXMgb2YgdGhlIC1jb3VudCBhbmQgLXJlZ2lzdGVyIGF0dHJpYnV0ZXMsIGlmIHRoZSBvcHRpb25hbCBhcmd1bWVudAppcyBzdXBwbGllZCwgaXQgaXMgcmVtb3ZlZCBmcm9tIHRoZSBhcmd1bWVudCBsaXN0IGFuZCBpcyBhdmFpbGFibGUgdG8gdGhlCnJlcGxhY2VtZW50IHRleHQgc2VwYXJhdGVseS4KClJlcGxhY2VtZW50IHRleHQKClRoZSByZXBsYWNlbWVudCB0ZXh0IGZvciBhIHVzZXIgZGVmaW5lZCBjb21tYW5kIGlzIHNjYW5uZWQgZm9yIHNwZWNpYWwgZXNjYXBlCnNlcXVlbmNlcywgdXNpbmcgPC4uLj4gbm90YXRpb24uICBFc2NhcGUgc2VxdWVuY2VzIGFyZSByZXBsYWNlZCB3aXRoIHZhbHVlcwpmcm9tIHRoZSBlbnRlcmVkIGNvbW1hbmQgbGluZSwgYW5kIGFsbCBvdGhlciB0ZXh0IGlzIGNvcGllZCB1bmNoYW5nZWQuICBUaGUKcmVzdWx0aW5nIHN0cmluZyBpcyBleGVjdXRlZCBhcyBhbiBFeCBjb21tYW5kLiAgVG8gYXZvaWQgdGhlIHJlcGxhY2VtZW50IHVzZQo8bHQ+IGluIHBsYWNlIG9mIHRoZSBpbml0aWFsIDwuICBUaHVzIHRvIGluY2x1ZGUgIjxiYW5nPiIgbGl0ZXJhbGx5IHVzZQoiPGx0PmJhbmc+Ii4KClRoZSB2YWxpZCBlc2NhcGUgc2VxdWVuY2VzIGFyZQoKCQkJCQkJKjxsaW5lMT4qCgk8bGluZTE+CVRoZSBzdGFydGluZyBsaW5lIG9mIHRoZSBjb21tYW5kIHJhbmdlLgoJCQkJCQkqPGxpbmUyPioKCTxsaW5lMj4JVGhlIGZpbmFsIGxpbmUgb2YgdGhlIGNvbW1hbmQgcmFuZ2UuCgkJCQkJCSo8Y291bnQ+KgoJPGNvdW50PglBbnkgY291bnQgc3VwcGxpZWQgKGFzIGRlc2NyaWJlZCBmb3IgdGhlICctcmFuZ2UnCgkJYW5kICctY291bnQnIGF0dHJpYnV0ZXMpLgoJCQkJCQkqPGJhbmc+KgoJPGJhbmc+CShTZWUgdGhlICctYmFuZycgYXR0cmlidXRlKSBFeHBhbmRzIHRvIGEgISBpZiB0aGUKCQljb21tYW5kIHdhcyBleGVjdXRlZCB3aXRoIGEgISBtb2RpZmllciwgb3RoZXJ3aXNlCgkJZXhwYW5kcyB0byBub3RoaW5nLgoJCQkJCQkqPHJlZz4qICo8cmVnaXN0ZXI+KgoJPHJlZz4JKFNlZSB0aGUgJy1yZWdpc3RlcicgYXR0cmlidXRlKSBUaGUgb3B0aW9uYWwgcmVnaXN0ZXIsCgkJaWYgc3BlY2lmaWVkLiAgT3RoZXJ3aXNlLCBleHBhbmRzIHRvIG5vdGhpbmcuICA8cmVnaXN0ZXI+CgkJaXMgYSBzeW5vbnltIGZvciB0aGlzLgoJCQkJCQkqPGFyZ3M+KgoJPGFyZ3M+CVRoZSBjb21tYW5kIGFyZ3VtZW50cywgZXhhY3RseSBhcyBzdXBwbGllZCAoYnV0IGFzCgkJbm90ZWQgYWJvdmUsIGFueSBjb3VudCBvciByZWdpc3RlciBjYW4gY29uc3VtZSBzb21lCgkJb2YgdGhlIGFyZ3VtZW50cywgd2hpY2ggYXJlIHRoZW4gbm90IHBhcnQgb2YgPGFyZ3M+KS4KCTxsdD4JQSBzaW5nbGUgJzwnIChMZXNzLVRoYW4pIGNoYXJhY3Rlci4gIFRoaXMgaXMgbmVlZGVkIGlmIHlvdQoJCXdhbnQgdG8gZ2V0IGEgbGl0ZXJhbCBjb3B5IG9mIG9uZSBvZiB0aGVzZSBlc2NhcGUgc2VxdWVuY2VzCgkJaW50byB0aGUgZXhwYW5zaW9uIC0gZm9yIGV4YW1wbGUsIHRvIGdldCA8YmFuZz4sIHVzZQoJCTxsdD5iYW5nPi4KCgkJCQkJCQkqPHEtYXJncz4qCklmIHRoZSBmaXJzdCB0d28gY2hhcmFjdGVycyBvZiBhbiBlc2NhcGUgc2VxdWVuY2UgYXJlICJxLSIgKGZvciBleGFtcGxlLAo8cS1hcmdzPikgdGhlbiB0aGUgdmFsdWUgaXMgcXVvdGVkIGluIHN1Y2ggYSB3YXkgYXMgdG8gbWFrZSBpdCBhIHZhbGlkIHZhbHVlCmZvciB1c2UgaW4gYW4gZXhwcmVzc2lvbi4gIFRoaXMgdXNlcyB0aGUgYXJndW1lbnQgYXMgb25lIHNpbmdsZSB2YWx1ZS4KV2hlbiB0aGVyZSBpcyBubyBhcmd1bWVudCA8cS1hcmdzPiBpcyBhbiBlbXB0eSBzdHJpbmcuCgkJCQkJCQkqPGYtYXJncz4qClRvIGFsbG93IGNvbW1hbmRzIHRvIHBhc3MgdGhlaXIgYXJndW1lbnRzIG9uIHRvIGEgdXNlci1kZWZpbmVkIGZ1bmN0aW9uLCB0aGVyZQppcyBhIHNwZWNpYWwgZm9ybSA8Zi1hcmdzPiAoImZ1bmN0aW9uIGFyZ3MiKS4gIFRoaXMgc3BsaXRzIHRoZSBjb21tYW5kCmFyZ3VtZW50cyBhdCBzcGFjZXMgYW5kIHRhYnMsIHF1b3RlcyBlYWNoIGFyZ3VtZW50IGluZGl2aWR1YWxseSwgYW5kIHRoZQo8Zi1hcmdzPiBzZXF1ZW5jZSBpcyByZXBsYWNlZCBieSB0aGUgY29tbWEtc2VwYXJhdGVkIGxpc3Qgb2YgcXVvdGVkIGFyZ3VtZW50cy4KU2VlIHRoZSBNeWNtZCBleGFtcGxlIGJlbG93LiAgSWYgbm8gYXJndW1lbnRzIGFyZSBnaXZlbiA8Zi1hcmdzPiBpcyByZW1vdmVkLgogICBUbyBlbWJlZCB3aGl0ZXNwYWNlIGludG8gYW4gYXJndW1lbnQgb2YgPGYtYXJncz4sIHByZXBlbmQgYSBiYWNrc2xhc2guCjxmLWFyZ3M+IHJlcGxhY2VzIGV2ZXJ5IHBhaXIgb2YgYmFja3NsYXNoZXMgKFxcKSB3aXRoIG9uZSBiYWNrc2xhc2guICBBCmJhY2tzbGFzaCBmb2xsb3dlZCBieSBhIGNoYXJhY3RlciBvdGhlciB0aGFuIHdoaXRlIHNwYWNlIG9yIGEgYmFja3NsYXNoCnJlbWFpbnMgdW5tb2RpZmllZC4gIE92ZXJ2aWV3OgoKCWNvbW1hbmQJCSAgIDxmLWFyZ3M+IH4KCVhYIGFiCQkgICAnYWInCglYWCBhXGIJCSAgICdhXGInCglYWCBhXCBiCQkgICAnYSBiJwoJWFggYVwgIGIJICAgJ2EgJywgJ2InCglYWCBhXFxiCQkgICAnYVxiJwoJWFggYVxcIGIJICAgJ2FcJywgJ2InCglYWCBhXFxcYgkgICAnYVxcYicKCVhYIGFcXFwgYgkgICAnYVwgYicKCVhYIGFcXFxcYgkgICAnYVxcYicKCVhYIGFcXFxcIGIJICAgJ2FcXCcsICdiJwoKRXhhbXBsZXMgPgoKICAgIiBEZWxldGUgZXZlcnl0aGluZyBhZnRlciBoZXJlIHRvIHRoZSBlbmQKICAgOmNvbSBEZGVsICssJGQKCiAgICIgUmVuYW1lIHRoZSBjdXJyZW50IGJ1ZmZlcgogICA6Y29tIC1uYXJncz0xIC1iYW5nIC1jb21wbGV0ZT1maWxlIFJlbiBmIDxhcmdzPnx3PGJhbmc+CgogICAiIFJlcGxhY2UgYSByYW5nZSB3aXRoIHRoZSBjb250ZW50cyBvZiBhIGZpbGUKICAgIiAoRW50ZXIgdGhpcyBhbGwgYXMgb25lIGxpbmUpCiAgIDpjb20gLXJhbmdlIC1uYXJncz0xIC1jb21wbGV0ZT1maWxlCgkgUmVwbGFjZSA8bGluZTE+LXB1X3w8bGluZTE+LDxsaW5lMj5kfHIgPGFyZ3M+fDxsaW5lMT5kCgogICAiIENvdW50IHRoZSBudW1iZXIgb2YgbGluZXMgaW4gdGhlIHJhbmdlCiAgIDpjb20hIC1yYW5nZSAtbmFyZ3M9MCBMaW5lcyAgZWNobyA8bGluZTI+IC0gPGxpbmUxPiArIDEgImxpbmVzIgoKICAgIiBDYWxsIGEgdXNlciBmdW5jdGlvbiAoZXhhbXBsZSBvZiA8Zi1hcmdzPikKICAgOmNvbSAtbmFyZ3M9KiBNeWNtZCBjYWxsIE15ZnVuYyg8Zi1hcmdzPikKCldoZW4gZXhlY3V0ZWQgYXM6ID4KCTpNeWNtZCBhcmcxIGFyZzIKVGhpcyB3aWxsIGludm9rZTogPgoJOmNhbGwgTXlmdW5jKCJhcmcxIiwiYXJnMiIpCgogICA6IiBBIG1vcmUgc3Vic3RhbnRpYWwgZXhhbXBsZQogICA6ZnVuY3Rpb24gQWxsYXJncyhjb21tYW5kKQogICA6ICAgbGV0IGkgPSAwCiAgIDogICB3aGlsZSBpIDwgYXJnYygpCiAgIDoJICBpZiBmaWxlcmVhZGFibGUoYXJndihpKSkKICAgOgkgICAgIGV4ZWN1dGUgImUgIiAuIGFyZ3YoaSkKICAgOgkgICAgIGV4ZWN1dGUgYTpjb21tYW5kCiAgIDogICAgICBlbmRpZgogICA6ICAgICAgbGV0IGkgPSBpICsgMQogICA6ICAgZW5kd2hpbGUKICAgOmVuZGZ1bmN0aW9uCiAgIDpjb21tYW5kIC1uYXJncz0rIC1jb21wbGV0ZT1jb21tYW5kIEFsbGFyZ3MgY2FsbCBBbGxhcmdzKDxxLWFyZ3M+KQoKVGhlIGNvbW1hbmQgQWxsYXJncyB0YWtlcyBhbnkgVmltIGNvbW1hbmQocykgYXMgYXJndW1lbnQgYW5kIGV4ZWN1dGVzIGl0IG9uIGFsbApmaWxlcyBpbiB0aGUgYXJndW1lbnQgbGlzdC4gIFVzYWdlIGV4YW1wbGUgKG5vdGUgdXNlIG9mIHRoZSAiZSIgZmxhZyB0byBpZ25vcmUKZXJyb3JzIGFuZCB0aGUgInVwZGF0ZSIgY29tbWFuZCB0byB3cml0ZSBtb2RpZmllZCBidWZmZXJzKTogPgoJOkFsbGFyZ3MgJXMvZm9vL2Jhci9nZXx1cGRhdGUKVGhpcyB3aWxsIGludm9rZTogPgoJOmNhbGwgQWxsYXJncygiJXMvZm9vL2Jhci9nZXx1cGRhdGUiKQo8CldoZW4gZGVmaW5pbmcgYSB1c2VyIGNvbW1hbmQgaW4gYSBzY3JpcHQsIGl0IHdpbGwgYmUgYWJsZSB0byBjYWxsIGZ1bmN0aW9ucwpsb2NhbCB0byB0aGUgc2NyaXB0IGFuZCB1c2UgbWFwcGluZ3MgbG9jYWwgdG8gdGhlIHNjcmlwdC4gIFdoZW4gdGhlIHVzZXIKaW52b2tlcyB0aGUgdXNlciBjb21tYW5kLCBpdCB3aWxsIHJ1biBpbiB0aGUgY29udGV4dCBvZiB0aGUgc2NyaXB0IGl0IHdhcwpkZWZpbmVkIGluLiAgVGhpcyBtYXR0ZXJzIGlmIHw8U0lEPnwgaXMgdXNlZCBpbiBhIGNvbW1hbmQuCgogdmltOnR3PTc4OnRzPTg6ZnQ9aGVscDpub3JsOgo=