Km1hcC50eHQqICAgICAgIEZvciBWaW0gdmVyc2lvbiA3LjMuICBMYXN0IGNoYW5nZTogMjAxMyBNYXkgMDUKCgoJCSAgVklNIFJFRkVSRU5DRSBNQU5VQUwgICAgYnkgQnJhbSBNb29sZW5hYXIKCgpLZXkgbWFwcGluZywgYWJicmV2aWF0aW9ucyBhbmQgdXNlci1kZWZpbmVkIGNvbW1hbmRzLgoKVGhpcyBzdWJqZWN0IGlzIGludHJvZHVjZWQgaW4gc2VjdGlvbnMgfDA1LjN8LCB8MjQuN3wgYW5kIHw0MC4xfCBvZiB0aGUgdXNlcgptYW51YWwuCgoxLiBLZXkgbWFwcGluZwkJCXxrZXktbWFwcGluZ3wKICAgMS4xIE1BUCBDT01NQU5EUwkJCXw6bWFwLWNvbW1hbmRzfAogICAxLjIgU3BlY2lhbCBhcmd1bWVudHMJCXw6bWFwLWFyZ3VtZW50c3wKICAgMS4zIE1hcHBpbmcgYW5kIG1vZGVzCQl8Om1hcC1tb2Rlc3wKICAgMS40IExpc3RpbmcgbWFwcGluZ3MJCQl8bWFwLWxpc3Rpbmd8CiAgIDEuNSBNYXBwaW5nIHNwZWNpYWwga2V5cwkJfDptYXAtc3BlY2lhbC1rZXlzfAogICAxLjYgU3BlY2lhbCBjaGFyYWN0ZXJzCQl8Om1hcC1zcGVjaWFsLWNoYXJzfAogICAxLjcgV2hhdCBrZXlzIHRvIG1hcAkJCXxtYXAtd2hpY2gta2V5c3wKICAgMS44IEV4YW1wbGVzCQkJCXxtYXAtZXhhbXBsZXN8CiAgIDEuOSBVc2luZyBtYXBwaW5ncwkJCXxtYXAtdHlwaW5nfAogICAxLjEwIE1hcHBpbmcgYWx0LWtleXMJCXw6bWFwLWFsdC1rZXlzfAogICAxLjExIE1hcHBpbmcgYW4gb3BlcmF0b3IJCXw6bWFwLW9wZXJhdG9yfAoyLiBBYmJyZXZpYXRpb25zCQl8YWJicmV2aWF0aW9uc3wKMy4gTG9jYWwgbWFwcGluZ3MgYW5kIGZ1bmN0aW9ucwl8c2NyaXB0LWxvY2FsfAo0LiBVc2VyLWRlZmluZWQgY29tbWFuZHMJfHVzZXItY29tbWFuZHN8Cgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KMS4gS2V5IG1hcHBpbmcJCQkJKmtleS1tYXBwaW5nKiAqbWFwcGluZyogKm1hY3JvKgoKS2V5IG1hcHBpbmcgaXMgdXNlZCB0byBjaGFuZ2UgdGhlIG1lYW5pbmcgb2YgdHlwZWQga2V5cy4gIFRoZSBtb3N0IGNvbW1vbiB1c2UKaXMgdG8gZGVmaW5lIGEgc2VxdWVuY2UgY29tbWFuZHMgZm9yIGEgZnVuY3Rpb24ga2V5LiAgRXhhbXBsZTogPgoKCTptYXAgPEYyPiBhPEMtUj49c3RyZnRpbWUoIiVjIik8Q1I+PEVzYz4KClRoaXMgYXBwZW5kcyB0aGUgY3VycmVudCBkYXRlIGFuZCB0aW1lIGFmdGVyIHRoZSBjdXJzb3IgKGluIDw+IG5vdGF0aW9uIHw8PnwpLgoKCjEuMSBNQVAgQ09NTUFORFMJCQkJCSo6bWFwLWNvbW1hbmRzKgoKVGhlcmUgYXJlIGNvbW1hbmRzIHRvIGVudGVyIG5ldyBtYXBwaW5ncywgcmVtb3ZlIG1hcHBpbmdzIGFuZCBsaXN0IG1hcHBpbmdzLgpTZWUgfG1hcC1vdmVydmlld3wgZm9yIHRoZSB2YXJpb3VzIGZvcm1zIG9mICJtYXAiIGFuZCB0aGVpciByZWxhdGlvbnNoaXBzIHdpdGgKbW9kZXMuCgp7bGhzfQltZWFucyBsZWZ0LWhhbmQtc2lkZQkqe2xoc30qCntyaHN9CW1lYW5zIHJpZ2h0LWhhbmQtc2lkZQkqe3Joc30qCgo6bWFwCXtsaHN9IHtyaHN9CQl8bWFwbW9kZS1udm98CQkqOm1hcCoKOm5tW2FwXQl7bGhzfSB7cmhzfQkJfG1hcG1vZGUtbnwJCSo6bm0qICo6bm1hcCoKOnZtW2FwXQl7bGhzfSB7cmhzfQkJfG1hcG1vZGUtdnwJCSo6dm0qICo6dm1hcCoKOnhtW2FwXQl7bGhzfSB7cmhzfQkJfG1hcG1vZGUteHwJCSo6eG0qICo6eG1hcCoKOnNtYXAJe2xoc30ge3Joc30JCXxtYXBtb2RlLXN8CQkgICAgKjpzbWFwKgo6b21bYXBdCXtsaHN9IHtyaHN9CQl8bWFwbW9kZS1vfAkJKjpvbSogKjpvbWFwKgo6bWFwIQl7bGhzfSB7cmhzfQkJfG1hcG1vZGUtaWN8CQkqOm1hcCEqCjppbVthcF0Je2xoc30ge3Joc30JCXxtYXBtb2RlLWl8CQkqOmltKiAqOmltYXAqCjpsbVthcF0Je2xoc30ge3Joc30JCXxtYXBtb2RlLWx8CQkqOmxtKiAqOmxtYXAqCjpjbVthcF0Je2xoc30ge3Joc30JCXxtYXBtb2RlLWN8CQkqOmNtKiAqOmNtYXAqCgkJCU1hcCB0aGUga2V5IHNlcXVlbmNlIHtsaHN9IHRvIHtyaHN9IGZvciB0aGUgbW9kZXMKCQkJd2hlcmUgdGhlIG1hcCBjb21tYW5kIGFwcGxpZXMuICBUaGUgcmVzdWx0LCBpbmNsdWRpbmcKCQkJe3Joc30sIGlzIHRoZW4gZnVydGhlciBzY2FubmVkIGZvciBtYXBwaW5ncy4gIFRoaXMKCQkJYWxsb3dzIGZvciBuZXN0ZWQgYW5kIHJlY3Vyc2l2ZSB1c2Ugb2YgbWFwcGluZ3MuCgoKOm5vW3JlbWFwXSAge2xoc30ge3Joc30JCXxtYXBtb2RlLW52b3wJCSo6bm8qICAqOm5vcmVtYXAqCjpubltvcmVtYXBdIHtsaHN9IHtyaHN9CQl8bWFwbW9kZS1ufAkJKjpubiogICo6bm5vcmVtYXAqCjp2bltvcmVtYXBdIHtsaHN9IHtyaHN9CQl8bWFwbW9kZS12fAkJKjp2biogICo6dm5vcmVtYXAqCjp4bltvcmVtYXBdIHtsaHN9IHtyaHN9CQl8bWFwbW9kZS14fAkJKjp4biogICo6eG5vcmVtYXAqCjpzbm9yW2VtYXBdIHtsaHN9IHtyaHN9CQl8bWFwbW9kZS1zfAkJKjpzbm9yKiAqOnNub3JlbWFwKgo6b25vW3JlbWFwXSB7bGhzfSB7cmhzfQkJfG1hcG1vZGUtb3wJCSo6b25vKiAqOm9ub3JlbWFwKgo6bm9bcmVtYXBdISB7bGhzfSB7cmhzfQkJfG1hcG1vZGUtaWN8CQkqOm5vISogKjpub3JlbWFwISoKOmlub1tyZW1hcF0ge2xoc30ge3Joc30JCXxtYXBtb2RlLWl8CQkqOmlubyogKjppbm9yZW1hcCoKOmxuW29yZW1hcF0ge2xoc30ge3Joc30JCXxtYXBtb2RlLWx8CQkqOmxuKiAgKjpsbm9yZW1hcCoKOmNub1tyZW1hcF0ge2xoc30ge3Joc30JCXxtYXBtb2RlLWN8CQkqOmNubyogKjpjbm9yZW1hcCoKCQkJTWFwIHRoZSBrZXkgc2VxdWVuY2Uge2xoc30gdG8ge3Joc30gZm9yIHRoZSBtb2RlcwoJCQl3aGVyZSB0aGUgbWFwIGNvbW1hbmQgYXBwbGllcy4gIERpc2FsbG93IG1hcHBpbmcgb2YKCQkJe3Joc30sIHRvIGF2b2lkIG5lc3RlZCBhbmQgcmVjdXJzaXZlIG1hcHBpbmdzLiAgT2Z0ZW4KCQkJdXNlZCB0byByZWRlZmluZSBhIGNvbW1hbmQuICB7bm90IGluIFZpfQoKCjp1bm1bYXBdICB7bGhzfQkJCXxtYXBtb2RlLW52b3wJCSo6dW5tKiAgKjp1bm1hcCoKOm51blttYXBdIHtsaHN9CQkJfG1hcG1vZGUtbnwJCSo6bnVuKiAgKjpudW5tYXAqCjp2dVtubWFwXSB7bGhzfQkJCXxtYXBtb2RlLXZ8CQkqOnZ1KiAgICo6dnVubWFwKgo6eHVbbm1hcF0ge2xoc30JCQl8bWFwbW9kZS14fAkJKjp4dSogICAqOnh1bm1hcCoKOnN1bm1bYXBdIHtsaHN9CQkJfG1hcG1vZGUtc3wJCSo6c3VubSogKjpzdW5tYXAqCjpvdVtubWFwXSB7bGhzfQkJCXxtYXBtb2RlLW98CQkqOm91KiAgICo6b3VubWFwKgo6dW5tW2FwXSEge2xoc30JCQl8bWFwbW9kZS1pY3wJCSo6dW5tISogKjp1bm1hcCEqCjppdVtubWFwXSB7bGhzfQkJCXxtYXBtb2RlLWl8CQkqOml1KiAgICo6aXVubWFwKgo6bHVbbm1hcF0ge2xoc30JCQl8bWFwbW9kZS1sfAkJKjpsdSogICAqOmx1bm1hcCoKOmN1W25tYXBdIHtsaHN9CQkJfG1hcG1vZGUtY3wJCSo6Y3UqICAgKjpjdW5tYXAqCgkJCVJlbW92ZSB0aGUgbWFwcGluZyBvZiB7bGhzfSBmb3IgdGhlIG1vZGVzIHdoZXJlIHRoZQoJCQltYXAgY29tbWFuZCBhcHBsaWVzLiAgVGhlIG1hcHBpbmcgbWF5IHJlbWFpbiBkZWZpbmVkCgkJCWZvciBvdGhlciBtb2RlcyB3aGVyZSBpdCBhcHBsaWVzLgoJCQlOb3RlOiBUcmFpbGluZyBzcGFjZXMgYXJlIGluY2x1ZGVkIGluIHRoZSB7bGhzfS4gIFRoaXMKCQkJdW5tYXAgZG9lcyBOT1Qgd29yazogPgoJCQkJOm1hcCBAQCBmb28KCQkJCTp1bm1hcCBAQCB8IHByaW50Cgo6bWFwY1tsZWFyXQkJCXxtYXBtb2RlLW52b3wJCSo6bWFwYyogICAqOm1hcGNsZWFyKgo6bm1hcGNbbGVhcl0JCQl8bWFwbW9kZS1ufAkJKjpubWFwYyogICo6bm1hcGNsZWFyKgo6dm1hcGNbbGVhcl0JCQl8bWFwbW9kZS12fAkJKjp2bWFwYyogICo6dm1hcGNsZWFyKgo6eG1hcGNbbGVhcl0JCQl8bWFwbW9kZS14fAkJKjp4bWFwYyogICo6eG1hcGNsZWFyKgo6c21hcGNbbGVhcl0JCQl8bWFwbW9kZS1zfAkJKjpzbWFwYyogICo6c21hcGNsZWFyKgo6b21hcGNbbGVhcl0JCQl8bWFwbW9kZS1vfAkJKjpvbWFwYyogICo6b21hcGNsZWFyKgo6bWFwY1tsZWFyXSEJCQl8bWFwbW9kZS1pY3wJCSo6bWFwYyEqICAqOm1hcGNsZWFyISoKOmltYXBjW2xlYXJdCQkJfG1hcG1vZGUtaXwJCSo6aW1hcGMqICAqOmltYXBjbGVhcioKOmxtYXBjW2xlYXJdCQkJfG1hcG1vZGUtbHwJCSo6bG1hcGMqICAqOmxtYXBjbGVhcioKOmNtYXBjW2xlYXJdCQkJfG1hcG1vZGUtY3wJCSo6Y21hcGMqICAqOmNtYXBjbGVhcioKCQkJUmVtb3ZlIEFMTCBtYXBwaW5ncyBmb3IgdGhlIG1vZGVzIHdoZXJlIHRoZSBtYXAKCQkJY29tbWFuZCBhcHBsaWVzLiAge25vdCBpbiBWaX0KCQkJVXNlIHRoZSA8YnVmZmVyPiBhcmd1bWVudCB0byByZW1vdmUgYnVmZmVyLWxvY2FsCgkJCW1hcHBpbmdzIHw6bWFwLTxidWZmZXI+fAoJCQlXYXJuaW5nOiBUaGlzIGFsc28gcmVtb3ZlcyB0aGUgZGVmYXVsdCBtYXBwaW5ncy4KCjptYXAJCQkJfG1hcG1vZGUtbnZvfAo6bm1bYXBdCQkJCXxtYXBtb2RlLW58Cjp2bVthcF0JCQkJfG1hcG1vZGUtdnwKOnhtW2FwXQkJCQl8bWFwbW9kZS14fAo6c21bYXBdCQkJCXxtYXBtb2RlLXN8CjpvbVthcF0JCQkJfG1hcG1vZGUtb3wKOm1hcCEJCQkJfG1hcG1vZGUtaWN8CjppbVthcF0JCQkJfG1hcG1vZGUtaXwKOmxtW2FwXQkJCQl8bWFwbW9kZS1sfAo6Y21bYXBdCQkJCXxtYXBtb2RlLWN8CgkJCUxpc3QgYWxsIGtleSBtYXBwaW5ncyBmb3IgdGhlIG1vZGVzIHdoZXJlIHRoZSBtYXAKCQkJY29tbWFuZCBhcHBsaWVzLiAgTm90ZSB0aGF0ICI6bWFwIiBhbmQgIjptYXAhIiBhcmUKCQkJdXNlZCBtb3N0IG9mdGVuLCBiZWNhdXNlIHRoZXkgaW5jbHVkZSB0aGUgb3RoZXIgbW9kZXMuCgo6bWFwICAgIHtsaHN9CQkJfG1hcG1vZGUtbnZvfAkJKjptYXBfbCoKOm5tW2FwXSB7bGhzfQkJCXxtYXBtb2RlLW58CQkqOm5tYXBfbCoKOnZtW2FwXSB7bGhzfQkJCXxtYXBtb2RlLXZ8CQkqOnZtYXBfbCoKOnhtW2FwXSB7bGhzfQkJCXxtYXBtb2RlLXh8CQkqOnhtYXBfbCoKOnNtW2FwXSB7bGhzfQkJCXxtYXBtb2RlLXN8CQkqOnNtYXBfbCoKOm9tW2FwXSB7bGhzfQkJCXxtYXBtb2RlLW98CQkqOm9tYXBfbCoKOm1hcCEgICB7bGhzfQkJCXxtYXBtb2RlLWljfAkJKjptYXBfbCEqCjppbVthcF0ge2xoc30JCQl8bWFwbW9kZS1pfAkJKjppbWFwX2wqCjpsbVthcF0ge2xoc30JCQl8bWFwbW9kZS1sfAkJKjpsbWFwX2wqCjpjbVthcF0ge2xoc30JCQl8bWFwbW9kZS1jfAkJKjpjbWFwX2wqCgkJCUxpc3QgdGhlIGtleSBtYXBwaW5ncyBmb3IgdGhlIGtleSBzZXF1ZW5jZXMgc3RhcnRpbmcKCQkJd2l0aCB7bGhzfSBpbiB0aGUgbW9kZXMgd2hlcmUgdGhlIG1hcCBjb21tYW5kIGFwcGxpZXMuCgkJCXtub3QgaW4gVml9CgpUaGVzZSBjb21tYW5kcyBhcmUgdXNlZCB0byBtYXAgYSBrZXkgb3Iga2V5IHNlcXVlbmNlIHRvIGEgc3RyaW5nIG9mCmNoYXJhY3RlcnMuICBZb3UgY2FuIHVzZSB0aGlzIHRvIHB1dCBjb21tYW5kIHNlcXVlbmNlcyB1bmRlciBmdW5jdGlvbiBrZXlzLAp0cmFuc2xhdGUgb25lIGtleSBpbnRvIGFub3RoZXIsIGV0Yy4gIFNlZSB8Om1rZXhyY3wgZm9yIGhvdyB0byBzYXZlIGFuZApyZXN0b3JlIHRoZSBjdXJyZW50IG1hcHBpbmdzLgoKCQkJCQkJCSptYXAtYW1iaWd1b3VzKgpXaGVuIHR3byBtYXBwaW5ncyBzdGFydCB3aXRoIHRoZSBzYW1lIHNlcXVlbmNlIG9mIGNoYXJhY3RlcnMsIHRoZXkgYXJlCmFtYmlndW91cy4gIEV4YW1wbGU6ID4KCTppbWFwIGFhIGZvbwoJOmltYXAgYWFhIGJhcgpXaGVuIFZpbSBoYXMgcmVhZCAiYWEiLCBpdCB3aWxsIG5lZWQgdG8gZ2V0IGFub3RoZXIgY2hhcmFjdGVyIHRvIGJlIGFibGUgdG8KZGVjaWRlIGlmICJhYSIgb3IgImFhYSIgc2hvdWxkIGJlIG1hcHBlZC4gIFRoaXMgbWVhbnMgdGhhdCBhZnRlciB0eXBpbmcgImFhIgp0aGF0IG1hcHBpbmcgd29uJ3QgZ2V0IGV4cGFuZGVkIHlldCwgVmltIGlzIHdhaXRpbmcgZm9yIGFub3RoZXIgY2hhcmFjdGVyLgpJZiB5b3UgdHlwZSBhIHNwYWNlLCB0aGVuICJmb28iIHdpbGwgZ2V0IGluc2VydGVkLCBwbHVzIHRoZSBzcGFjZS4gIElmIHlvdQp0eXBlICJhIiwgdGhlbiAiYmFyIiB3aWxsIGdldCBpbnNlcnRlZC4Ke1ZpIGRvZXMgbm90IGFsbG93IGFtYmlndW91cyBtYXBwaW5nc30KCgoxLjIgU1BFQ0lBTCBBUkdVTUVOVFMJCQkJCSo6bWFwLWFyZ3VtZW50cyoKCiI8YnVmZmVyPiIsICI8c2lsZW50PiIsICI8c3BlY2lhbD4iLCAiPHNjcmlwdD4iLCAiPGV4cHI+IiBhbmQgIjx1bmlxdWU+IiBjYW4KYmUgdXNlZCBpbiBhbnkgb3JkZXIuICBUaGV5IG11c3QgYXBwZWFyIHJpZ2h0IGFmdGVyIHRoZSBjb21tYW5kLCBiZWZvcmUgYW55Cm90aGVyIGFyZ3VtZW50cy4KCgkJCQkqOm1hcC1sb2NhbCogKjptYXAtPGJ1ZmZlcj4qICpFMjI0KiAqRTIyNSoKSWYgdGhlIGZpcnN0IGFyZ3VtZW50IHRvIG9uZSBvZiB0aGVzZSBjb21tYW5kcyBpcyAiPGJ1ZmZlcj4iIHRoZSBtYXBwaW5nIHdpbGwKYmUgZWZmZWN0aXZlIGluIHRoZSBjdXJyZW50IGJ1ZmZlciBvbmx5LiAgRXhhbXBsZTogPgoJOm1hcCA8YnVmZmVyPiAgLHcgIC9bLiw7XTxDUj4KVGhlbiB5b3UgY2FuIG1hcCAiLHciIHRvIHNvbWV0aGluZyBlbHNlIGluIGFub3RoZXIgYnVmZmVyOiA+Cgk6bWFwIDxidWZmZXI+ICAsdyAgL1sjJiFdPENSPgpUaGUgbG9jYWwgYnVmZmVyIG1hcHBpbmdzIGFyZSB1c2VkIGJlZm9yZSB0aGUgZ2xvYmFsIG9uZXMuClRoZSAiPGJ1ZmZlcj4iIGFyZ3VtZW50IGNhbiBhbHNvIGJlIHVzZWQgdG8gY2xlYXIgbWFwcGluZ3M6ID4KCTp1bm1hcCA8YnVmZmVyPiAsdwoJOm1hcGNsZWFyIDxidWZmZXI+CkxvY2FsIG1hcHBpbmdzIGFyZSBhbHNvIGNsZWFyZWQgd2hlbiBhIGJ1ZmZlciBpcyBkZWxldGVkLCBidXQgbm90IHdoZW4gaXQgaXMKdW5sb2FkZWQuICBKdXN0IGxpa2UgbG9jYWwgb3B0aW9uIHZhbHVlcy4KCgkJCQkJCSo6bWFwLTxzaWxlbnQ+KiAqOm1hcC1zaWxlbnQqClRvIGRlZmluZSBhIG1hcHBpbmcgd2hpY2ggd2lsbCBub3QgYmUgZWNob2VkIG9uIHRoZSBjb21tYW5kIGxpbmUsIGFkZAoiPHNpbGVudD4iIGFzIHRoZSBmaXJzdCBhcmd1bWVudC4gIEV4YW1wbGU6ID4KCTptYXAgPHNpbGVudD4gLGggL0hlYWRlcjxDUj4KVGhlIHNlYXJjaCBzdHJpbmcgd2lsbCBub3QgYmUgZWNob2VkIHdoZW4gdXNpbmcgdGhpcyBtYXBwaW5nLiAgTWVzc2FnZXMgZnJvbQp0aGUgZXhlY3V0ZWQgY29tbWFuZCBhcmUgc3RpbGwgZ2l2ZW4gdGhvdWdoLiAgVG8gc2h1dCB0aGVtIHVwIHRvbywgYWRkIGEKIjpzaWxlbnQiIGluIHRoZSBleGVjdXRlZCBjb21tYW5kOiA+Cgk6bWFwIDxzaWxlbnQ+ICxoIDpleGUgIjpzaWxlbnQgbm9ybWFsIC9IZWFkZXJcciI8Q1I+ClByb21wdHMgd2lsbCBzdGlsbCBiZSBnaXZlbiwgZS5nLiwgZm9yIGlucHV0ZGlhbG9nKCkuClVzaW5nICI8c2lsZW50PiIgZm9yIGFuIGFiYnJldmlhdGlvbiBpcyBwb3NzaWJsZSwgYnV0IHdpbGwgY2F1c2UgcmVkcmF3aW5nIG9mCnRoZSBjb21tYW5kIGxpbmUgdG8gZmFpbC4KCgkJCQkJCSo6bWFwLTxzcGVjaWFsPiogKjptYXAtc3BlY2lhbCoKRGVmaW5lIGEgbWFwcGluZyB3aXRoIDw+IG5vdGF0aW9uIGZvciBzcGVjaWFsIGtleXMsIGV2ZW4gdGhvdWdoIHRoZSAiPCIgZmxhZwptYXkgYXBwZWFyIGluICdjcG9wdGlvbnMnLiAgVGhpcyBpcyB1c2VmdWwgaWYgdGhlIHNpZGUgZWZmZWN0IG9mIHNldHRpbmcKJ2Nwb3B0aW9ucycgaXMgbm90IGRlc2lyZWQuICBFeGFtcGxlOiA+Cgk6bWFwIDxzcGVjaWFsPiA8RjEyPiAvSGVhZGVyPENSPgo8CgkJCQkJCSo6bWFwLTxzY3JpcHQ+KiAqOm1hcC1zY3JpcHQqCklmIHRoZSBmaXJzdCBhcmd1bWVudCB0byBvbmUgb2YgdGhlc2UgY29tbWFuZHMgaXMgIjxzY3JpcHQ+IiBhbmQgaXQgaXMgdXNlZCB0bwpkZWZpbmUgYSBuZXcgbWFwcGluZyBvciBhYmJyZXZpYXRpb24sIHRoZSBtYXBwaW5nIHdpbGwgb25seSByZW1hcCBjaGFyYWN0ZXJzCmluIHRoZSB7cmhzfSB1c2luZyBtYXBwaW5ncyB0aGF0IHdlcmUgZGVmaW5lZCBsb2NhbCB0byBhIHNjcmlwdCwgc3RhcnRpbmcgd2l0aAoiPFNJRD4iLiAgVGhpcyBjYW4gYmUgdXNlZCB0byBhdm9pZCB0aGF0IG1hcHBpbmdzIGZyb20gb3V0c2lkZSBhIHNjcmlwdAppbnRlcmZlcmUgKGUuZy4sIHdoZW4gQ1RSTC1WIGlzIHJlbWFwcGVkIGluIG1zd2luLnZpbSksIGJ1dCBkbyB1c2Ugb3RoZXIKbWFwcGluZ3MgZGVmaW5lZCBpbiB0aGUgc2NyaXB0LgpOb3RlOiAiOm1hcCA8c2NyaXB0PiIgYW5kICI6bm9yZW1hcCA8c2NyaXB0PiIgZG8gdGhlIHNhbWUgdGhpbmcuICBUaGUKIjxzY3JpcHQ+IiBvdmVycnVsZXMgdGhlIGNvbW1hbmQgbmFtZS4gIFVzaW5nICI6bm9yZW1hcCA8c2NyaXB0PiIgaXMKcHJlZmVycmVkLCBiZWNhdXNlIGl0J3MgY2xlYXJlciB0aGF0IHJlbWFwcGluZyBpcyAobW9zdGx5KSBkaXNhYmxlZC4KCgkJCQkJCSo6bWFwLTx1bmlxdWU+KiAqRTIyNiogKkUyMjcqCklmIHRoZSBmaXJzdCBhcmd1bWVudCB0byBvbmUgb2YgdGhlc2UgY29tbWFuZHMgaXMgIjx1bmlxdWU+IiBhbmQgaXQgaXMgdXNlZCB0bwpkZWZpbmUgYSBuZXcgbWFwcGluZyBvciBhYmJyZXZpYXRpb24sIHRoZSBjb21tYW5kIHdpbGwgZmFpbCBpZiB0aGUgbWFwcGluZyBvcgphYmJyZXZpYXRpb24gYWxyZWFkeSBleGlzdHMuICBFeGFtcGxlOiA+Cgk6bWFwIDx1bmlxdWU+ICx3ICAvWyMmIV08Q1I+CldoZW4gZGVmaW5pbmcgYSBsb2NhbCBtYXBwaW5nLCB0aGVyZSB3aWxsIGFsc28gYmUgYSBjaGVjayBpZiBhIGdsb2JhbCBtYXAKYWxyZWFkeSBleGlzdHMgd2hpY2ggaXMgZXF1YWwuCkV4YW1wbGUgb2Ygd2hhdCB3aWxsIGZhaWw6ID4KCTptYXAgLHcgIC9bIyYhXTxDUj4KCTptYXAgPGJ1ZmZlcj4gPHVuaXF1ZT4gLHcgIC9bLiw7XTxDUj4KSWYgeW91IHdhbnQgdG8gbWFwIGEga2V5IGFuZCB0aGVuIGhhdmUgaXQgZG8gd2hhdCBpdCB3YXMgb3JpZ2luYWxseSBtYXBwZWQgdG8sCmhhdmUgYSBsb29rIGF0IHxtYXBhcmcoKXwuCgoJCQkJCQkqOm1hcC08ZXhwcj4qICo6bWFwLWV4cHJlc3Npb24qCklmIHRoZSBmaXJzdCBhcmd1bWVudCB0byBvbmUgb2YgdGhlc2UgY29tbWFuZHMgaXMgIjxleHByPiIgYW5kIGl0IGlzIHVzZWQgdG8KZGVmaW5lIGEgbmV3IG1hcHBpbmcgb3IgYWJicmV2aWF0aW9uLCB0aGUgYXJndW1lbnQgaXMgYW4gZXhwcmVzc2lvbi4gIFRoZQpleHByZXNzaW9uIGlzIGV2YWx1YXRlZCB0byBvYnRhaW4gdGhlIHtyaHN9IHRoYXQgaXMgdXNlZC4gIEV4YW1wbGU6ID4KCTppbm9yZW1hcCA8ZXhwcj4gLiBJbnNlcnREb3QoKQpUaGUgcmVzdWx0IG9mIHRoZSBJbnNlcnREb3QoKSBmdW5jdGlvbiB3aWxsIGJlIGluc2VydGVkLiAgSXQgY291bGQgY2hlY2sgdGhlCnRleHQgYmVmb3JlIHRoZSBjdXJzb3IgYW5kIHN0YXJ0IG9tbmkgY29tcGxldGlvbiB3aGVuIHNvbWUgY29uZGl0aW9uIGlzIG1ldC4KCkZvciBhYmJyZXZpYXRpb25zIHx2OmNoYXJ8IGlzIHNldCB0byB0aGUgY2hhcmFjdGVyIHRoYXQgd2FzIHR5cGVkIHRvIHRyaWdnZXIKdGhlIGFiYnJldmlhdGlvbi4gIFlvdSBjYW4gdXNlIHRoaXMgdG8gZGVjaWRlIGhvdyB0byBleHBhbmQgdGhlIHtsaHN9LiAgWW91CnNob3VsZCBub3QgZWl0aGVyIGluc2VydCBvciBjaGFuZ2UgdGhlIHY6Y2hhci4KCkJlIHZlcnkgY2FyZWZ1bCBhYm91dCBzaWRlIGVmZmVjdHMhICBUaGUgZXhwcmVzc2lvbiBpcyBldmFsdWF0ZWQgd2hpbGUKb2J0YWluaW5nIGNoYXJhY3RlcnMsIHlvdSBtYXkgdmVyeSB3ZWxsIG1ha2UgdGhlIGNvbW1hbmQgZHlzZnVuY3Rpb25hbC4KRm9yIHRoaXMgcmVhc29uIHRoZSBmb2xsb3dpbmcgaXMgYmxvY2tlZDoKLSBDaGFuZ2luZyB0aGUgYnVmZmVyIHRleHQgfHRleHRsb2NrfC4KLSBFZGl0aW5nIGFub3RoZXIgYnVmZmVyLgotIFRoZSB8Om5vcm1hbHwgY29tbWFuZC4KLSBNb3ZpbmcgdGhlIGN1cnNvciBpcyBhbGxvd2VkLCBidXQgaXQgaXMgcmVzdG9yZWQgYWZ0ZXJ3YXJkcy4KSWYgeW91IHdhbnQgdGhlIG1hcHBpbmcgdG8gZG8gYW55IG9mIHRoZXNlIGxldCB0aGUgcmV0dXJuZWQgY2hhcmFjdGVycyBkbwp0aGF0LgoKWW91IGNhbiB1c2UgZ2V0Y2hhcigpLCBpdCBjb25zdW1lcyB0eXBlYWhlYWQgaWYgdGhlcmUgaXMgYW55LiBFLmcuLCBpZiB5b3UKaGF2ZSB0aGVzZSBtYXBwaW5nczogPgogIGlub3JlbWFwIDxleHByPiA8Qy1MPiBucjJjaGFyKGdldGNoYXIoKSkKICBpbm9yZW1hcCA8ZXhwcj4gPEMtTD54ICJmb28iCklmIHlvdSBub3cgdHlwZSBDVFJMLUwgbm90aGluZyBoYXBwZW5zIHlldCwgVmltIG5lZWRzIHRoZSBuZXh0IGNoYXJhY3RlciB0bwpkZWNpZGUgd2hhdCBtYXBwaW5nIHRvIHVzZS4gIElmIHlvdSB0eXBlICd4JyB0aGUgc2Vjb25kIG1hcHBpbmcgaXMgdXNlZCBhbmQKImZvbyIgaXMgaW5zZXJ0ZWQuICBJZiB5b3UgdHlwZSBhbnkgb3RoZXIga2V5IHRoZSBmaXJzdCBtYXBwaW5nIGlzIHVzZWQsCmdldGNoYXIoKSBnZXRzIHRoZSB0eXBlZCBrZXkgYW5kIHJldHVybnMgaXQuCgpIZXJlIGlzIGFuIGV4YW1wbGUgdGhhdCBpbnNlcnRzIGEgbGlzdCBudW1iZXIgdGhhdCBpbmNyZWFzZXM6ID4KCWxldCBjb3VudGVyID0gMAoJaW5vcmVtYXAgPGV4cHI+IDxDLUw+IExpc3RJdGVtKCkKCWlub3JlbWFwIDxleHByPiA8Qy1SPiBMaXN0UmVzZXQoKQoKCWZ1bmMgTGlzdEl0ZW0oKQoJICBsZXQgZzpjb3VudGVyICs9IDEKCSAgcmV0dXJuIGc6Y291bnRlciAuICcuICcKCWVuZGZ1bmMKCglmdW5jIExpc3RSZXNldCgpCgkgIGxldCBnOmNvdW50ZXIgPSAwCgkgIHJldHVybiAnJwoJZW5kZnVuYwoKQ1RSTC1MIGluc2VydHMgdGhlIG5leHQgbnVtYmVyLCBDVFJMLVIgcmVzZXRzIHRoZSBjb3VudC4gIENUUkwtUiByZXR1cm5zIGFuCmVtcHR5IHN0cmluZywgc28gdGhhdCBub3RoaW5nIGlzIGluc2VydGVkLgoKTm90ZSB0aGF0IHRoZXJlIGFyZSBzb21lIHRyaWNrcyB0byBtYWtlIHNwZWNpYWwga2V5cyB3b3JrIGFuZCBlc2NhcGUgQ1NJIGJ5dGVzCmluIHRoZSB0ZXh0LiAgVGhlIHw6bWFwfCBjb21tYW5kIGFsc28gZG9lcyB0aGlzLCB0aHVzIHlvdSBtdXN0IGF2b2lkIHRoYXQgaXQKaXMgZG9uZSB0d2ljZS4gIFRoaXMgZG9lcyBub3Qgd29yazogPgoJOmltYXAgPGV4cHI+IDxGMz4gIjxDaGFyLTB4NjExQj4iCkJlY2F1c2UgdGhlIDxDaGFyLSBzZXF1ZW5jZSBpcyBlc2NhcGVkIGZvciBiZWluZyBhIHw6aW1hcHwgYXJndW1lbnQgYW5kIHRoZW4KYWdhaW4gZm9yIHVzaW5nIDxleHByPi4gIFRoaXMgZG9lcyB3b3JrOiA+Cgk6aW1hcCA8ZXhwcj4gPEYzPiAiXHU2MTFCIgpVc2luZyAweDgwIGFzIGEgc2luZ2xlIGJ5dGUgYmVmb3JlIG90aGVyIHRleHQgZG9lcyBub3Qgd29yaywgaXQgd2lsbCBiZSBzZWVuCmFzIGEgc3BlY2lhbCBrZXkuCgoKMS4zIE1BUFBJTkcgQU5EIE1PREVTCQkJCQkqOm1hcC1tb2RlcyoKCQkJKm1hcG1vZGUtbnZvKiAqbWFwbW9kZS1uKiAqbWFwbW9kZS12KiAqbWFwbW9kZS1vKgoKVGhlcmUgYXJlIHNpeCBzZXRzIG9mIG1hcHBpbmdzCi0gRm9yIE5vcm1hbCBtb2RlOiBXaGVuIHR5cGluZyBjb21tYW5kcy4KLSBGb3IgVmlzdWFsIG1vZGU6IFdoZW4gdHlwaW5nIGNvbW1hbmRzIHdoaWxlIHRoZSBWaXN1YWwgYXJlYSBpcyBoaWdobGlnaHRlZC4KLSBGb3IgU2VsZWN0IG1vZGU6IGxpa2UgVmlzdWFsIG1vZGUgYnV0IHR5cGluZyB0ZXh0IHJlcGxhY2VzIHRoZSBzZWxlY3Rpb24uCi0gRm9yIE9wZXJhdG9yLXBlbmRpbmcgbW9kZTogV2hlbiBhbiBvcGVyYXRvciBpcyBwZW5kaW5nIChhZnRlciAiZCIsICJ5IiwgImMiLAogIGV0Yy4pLiAgU2VlIGJlbG93OiB8b21hcC1pbmZvfC4KLSBGb3IgSW5zZXJ0IG1vZGUuICBUaGVzZSBhcmUgYWxzbyB1c2VkIGluIFJlcGxhY2UgbW9kZS4KLSBGb3IgQ29tbWFuZC1saW5lIG1vZGU6IFdoZW4gZW50ZXJpbmcgYSAiOiIgb3IgIi8iIGNvbW1hbmQuCgpTcGVjaWFsIGNhc2U6IFdoaWxlIHR5cGluZyBhIGNvdW50IGZvciBhIGNvbW1hbmQgaW4gTm9ybWFsIG1vZGUsIG1hcHBpbmcgemVybwppcyBkaXNhYmxlZC4gIFRoaXMgbWFrZXMgaXQgcG9zc2libGUgdG8gbWFwIHplcm8gd2l0aG91dCBtYWtpbmcgaXQgaW1wb3NzaWJsZQp0byB0eXBlIGEgY291bnQgd2l0aCBhIHplcm8uCgoJCQkJCQkqbWFwLW92ZXJ2aWV3KiAqbWFwLW1vZGVzKgpPdmVydmlldyBvZiB3aGljaCBtYXAgY29tbWFuZCB3b3JrcyBpbiB3aGljaCBtb2RlOgoKICAgIGNvbW1hbmRzOgkJCQkgICAgICBtb2RlczogfgoJCQkJICAgICAgIE5vcm1hbCAgVmlzdWFsK1NlbGVjdCAgT3BlcmF0b3ItcGVuZGluZyB+CjptYXAgICA6bm9yZW1hcCAgIDp1bm1hcCAgIDptYXBjbGVhcgkgeWVzCSAgICB5ZXMJCSAgIHllcwo6bm1hcCAgOm5ub3JlbWFwICA6bnVubWFwICA6bm1hcGNsZWFyCSB5ZXMJICAgICAtCQkgICAgLQo6dm1hcCAgOnZub3JlbWFwICA6dnVubWFwICA6dm1hcGNsZWFyCSAgLQkgICAgeWVzCQkgICAgLQo6b21hcCAgOm9ub3JlbWFwICA6b3VubWFwICA6b21hcGNsZWFyCSAgLQkgICAgIC0JCSAgIHllcwoKOm51bm1hcCBjYW4gYWxzbyBiZSB1c2VkIG91dHNpZGUgb2YgYSBtb25hc3RlcnkuCgkJCQkJCSptYXBtb2RlLXgqICptYXBtb2RlLXMqClNvbWUgY29tbWFuZHMgd29yayBib3RoIGluIFZpc3VhbCBhbmQgU2VsZWN0IG1vZGUsIHNvbWUgaW4gb25seSBvbmUuICBOb3RlCnRoYXQgcXVpdGUgb2Z0ZW4gIlZpc3VhbCIgaXMgbWVudGlvbmVkIHdoZXJlIGJvdGggVmlzdWFsIGFuZCBTZWxlY3QgbW9kZQphcHBseS4gfFNlbGVjdC1tb2RlLW1hcHBpbmd8Ck5PVEU6IE1hcHBpbmcgYSBwcmludGFibGUgY2hhcmFjdGVyIGluIFNlbGVjdCBtb2RlIG1heSBjb25mdXNlIHRoZSB1c2VyLiAgSXQncwpiZXR0ZXIgdG8gZXhwbGljaXRseSB1c2UgOnhtYXAgYW5kIDpzbWFwIGZvciBwcmludGFibGUgY2hhcmFjdGVycy4gIE9yIHVzZQo6c3VubWFwIGFmdGVyIGRlZmluaW5nIHRoZSBtYXBwaW5nLgoKICAgIGNvbW1hbmRzOgkJCQkgICAgICBtb2RlczogfgoJCQkJCSAgVmlzdWFsICAgIFNlbGVjdCB+Cjp2bWFwICA6dm5vcmVtYXAgIDp2dW5tYXAgIDp2bWFwY2xlYXIJICAgIHllcyAgICAgIHllcwo6eG1hcCAgOnhub3JlbWFwICA6eHVubWFwICA6eG1hcGNsZWFyCSAgICB5ZXMgICAgICAgLQo6c21hcCAgOnNub3JlbWFwICA6c3VubWFwICA6c21hcGNsZWFyCSAgICAtCSAgICAgeWVzCgoJCQkqbWFwbW9kZS1pYyogKm1hcG1vZGUtaSogKm1hcG1vZGUtYyogKm1hcG1vZGUtbCoKU29tZSBjb21tYW5kcyB3b3JrIGJvdGggaW4gSW5zZXJ0IG1vZGUgYW5kIENvbW1hbmQtbGluZSBtb2RlLCBzb21lIG5vdDoKCiAgICBjb21tYW5kczoJCQkJICAgICAgbW9kZXM6IH4KCQkJCQkgIEluc2VydCAgQ29tbWFuZC1saW5lCUxhbmctQXJnIH4KOm1hcCEgIDpub3JlbWFwISAgOnVubWFwISAgOm1hcGNsZWFyIQkgICAgeWVzCSAgICAgICB5ZXMJICAgLQo6aW1hcCAgOmlub3JlbWFwICA6aXVubWFwICA6aW1hcGNsZWFyCSAgICB5ZXMJCS0JICAgLQo6Y21hcCAgOmNub3JlbWFwICA6Y3VubWFwICA6Y21hcGNsZWFyCSAgICAgLQkgICAgICAgeWVzCSAgIC0KOmxtYXAgIDpsbm9yZW1hcCAgOmx1bm1hcCAgOmxtYXBjbGVhcgkgICAgeWVzKiAgICAgICB5ZXMqCSAgeWVzKgoKVGhlIG9yaWdpbmFsIFZpIGRpZCBub3QgaGF2ZSBzZXBhcmF0ZSBtYXBwaW5ncyBmb3IKTm9ybWFsL1Zpc3VhbC9PcGVyYXRvci1wZW5kaW5nIG1vZGUgYW5kIGZvciBJbnNlcnQvQ29tbWFuZC1saW5lIG1vZGUuClRoZXJlZm9yZSB0aGUgIjptYXAiIGFuZCAiOm1hcCEiIGNvbW1hbmRzIGVudGVyIGFuZCBkaXNwbGF5IG1hcHBpbmdzIGZvcgpzZXZlcmFsIG1vZGVzLiAgSW4gVmltIHlvdSBjYW4gdXNlIHRoZSAiOm5tYXAiLCAiOnZtYXAiLCAiOm9tYXAiLCAiOmNtYXAiIGFuZAoiOmltYXAiIGNvbW1hbmRzIHRvIGVudGVyIG1hcHBpbmdzIGZvciBlYWNoIG1vZGUgc2VwYXJhdGVseS4KCgkJCQkJCQkqb21hcC1pbmZvKgpPcGVyYXRvci1wZW5kaW5nIG1hcHBpbmdzIGNhbiBiZSB1c2VkIHRvIGRlZmluZSBhIG1vdmVtZW50IGNvbW1hbmQgdGhhdCBjYW4gYmUKdXNlZCB3aXRoIGFueSBvcGVyYXRvci4gIFNpbXBsZSBleGFtcGxlOiAiOm9tYXAgeyB3IiBtYWtlcyAieXsiIHdvcmsgbGlrZSAieXciCmFuZCAiZHsiIGxpa2UgImR3Ii4KClRvIGlnbm9yZSB0aGUgc3RhcnRpbmcgY3Vyc29yIHBvc2l0aW9uIGFuZCBzZWxlY3QgZGlmZmVyZW50IHRleHQsIHlvdSBjYW4gaGF2ZQp0aGUgb21hcCBzdGFydCBWaXN1YWwgbW9kZSB0byBzZWxlY3QgdGhlIHRleHQgdG8gYmUgb3BlcmF0ZWQgdXBvbi4gIEV4YW1wbGUKdGhhdCBvcGVyYXRlcyBvbiBhIGZ1bmN0aW9uIG5hbWUgaW4gdGhlIGN1cnJlbnQgbGluZTogPgoJb25vcmVtYXAgPHNpbGVudD4gRiA6PEMtVT5ub3JtYWwhIDBmKGh2aXc8Q1I+ClRoZSBDVFJMLVUgKDxDLVU+KSBpcyB1c2VkIHRvIHJlbW92ZSB0aGUgcmFuZ2UgdGhhdCBWaW0gbWF5IGluc2VydC4gIFRoZQpOb3JtYWwgbW9kZSBjb21tYW5kcyBmaW5kIHRoZSBmaXJzdCAnKCcgY2hhcmFjdGVyIGFuZCBzZWxlY3QgdGhlIGZpcnN0IHdvcmQKYmVmb3JlIGl0LiAgVGhhdCB1c3VhbGx5IGlzIHRoZSBmdW5jdGlvbiBuYW1lLgoKVG8gZW50ZXIgYSBtYXBwaW5nIGZvciBOb3JtYWwgYW5kIFZpc3VhbCBtb2RlLCBidXQgbm90IE9wZXJhdG9yLXBlbmRpbmcgbW9kZSwKZmlyc3QgZGVmaW5lIGl0IGZvciBhbGwgdGhyZWUgbW9kZXMsIHRoZW4gdW5tYXAgaXQgZm9yIE9wZXJhdG9yLXBlbmRpbmcgbW9kZToKCTptYXAgICAgeHggc29tZXRoaW5nLWRpZmZpY3VsdAoJOm91bm1hcCB4eApMaWtld2lzZSBmb3IgYSBtYXBwaW5nIGZvciBWaXN1YWwgYW5kIE9wZXJhdG9yLXBlbmRpbmcgbW9kZSBvciBOb3JtYWwgYW5kCk9wZXJhdG9yLXBlbmRpbmcgbW9kZS4KCgkJCQkJCSpsYW5ndWFnZS1tYXBwaW5nKgoiOmxtYXAiIGRlZmluZXMgYSBtYXBwaW5nIHRoYXQgYXBwbGllcyB0bzoKLSBJbnNlcnQgbW9kZQotIENvbW1hbmQtbGluZSBtb2RlCi0gd2hlbiBlbnRlcmluZyBhIHNlYXJjaCBwYXR0ZXJuCi0gdGhlIGFyZ3VtZW50IG9mIHRoZSBjb21tYW5kcyB0aGF0IGFjY2VwdCBhIHRleHQgY2hhcmFjdGVyLCBzdWNoIGFzICJyIiBhbmQKICAiZiIKLSBmb3IgdGhlIGlucHV0KCkgbGluZQpHZW5lcmFsbHk6IFdoZW5ldmVyIGEgY2hhcmFjdGVyIGlzIHRvIGJlIHR5cGVkIHRoYXQgaXMgcGFydCBvZiB0aGUgdGV4dCBpbiB0aGUKYnVmZmVyLCBub3QgYSBWaW0gY29tbWFuZCBjaGFyYWN0ZXIuICAiTGFuZy1BcmciIGlzbid0IHJlYWxseSBhbm90aGVyIG1vZGUsCml0J3MganVzdCB1c2VkIGhlcmUgZm9yIHRoaXMgc2l0dWF0aW9uLgogICBUaGUgc2ltcGxlc3Qgd2F5IHRvIGxvYWQgYSBzZXQgb2YgcmVsYXRlZCBsYW5ndWFnZSBtYXBwaW5ncyBpcyBieSB1c2luZyB0aGUKJ2tleW1hcCcgb3B0aW9uLiAgU2VlIHw0NS41fC4KICAgSW4gSW5zZXJ0IG1vZGUgYW5kIGluIENvbW1hbmQtbGluZSBtb2RlIHRoZSBtYXBwaW5ncyBjYW4gYmUgZGlzYWJsZWQgd2l0aAp0aGUgQ1RSTC1eIGNvbW1hbmQgfGlfQ1RSTC1efCB8Y19DVFJMLV58LiAgV2hlbiBzdGFydGluZyB0byBlbnRlciBhIG5vcm1hbApjb21tYW5kIGxpbmUgKG5vdCBhIHNlYXJjaCBwYXR0ZXJuKSB0aGUgbWFwcGluZ3MgYXJlIGRpc2FibGVkIHVudGlsIGEgQ1RSTC1eCmlzIHR5cGVkLiAgVGhlIHN0YXRlIGxhc3QgdXNlZCBpcyByZW1lbWJlcmVkIGZvciBJbnNlcnQgbW9kZSBhbmQgU2VhcmNoCnBhdHRlcm5zIHNlcGFyYXRlbHkuICBUaGUgc3RhdGUgZm9yIEluc2VydCBtb2RlIGlzIGFsc28gdXNlZCB3aGVuIHR5cGluZyBhCmNoYXJhY3RlciBhcyBhbiBhcmd1bWVudCB0byBjb21tYW5kIGxpa2UgImYiIG9yICJ0Ii4KICAgTGFuZ3VhZ2UgbWFwcGluZ3Mgd2lsbCBuZXZlciBiZSBhcHBsaWVkIHRvIGFscmVhZHkgbWFwcGVkIGNoYXJhY3RlcnMuICBUaGV5CmFyZSBvbmx5IHVzZWQgZm9yIHR5cGVkIGNoYXJhY3RlcnMuICBUaGlzIGFzc3VtZXMgdGhhdCB0aGUgbGFuZ3VhZ2UgbWFwcGluZwp3YXMgYWxyZWFkeSBkb25lIHdoZW4gdHlwaW5nIHRoZSBtYXBwaW5nLgoKCjEuNCBMSVNUSU5HIE1BUFBJTkdTCQkJCQkqbWFwLWxpc3RpbmcqCgpXaGVuIGxpc3RpbmcgbWFwcGluZ3MgdGhlIGNoYXJhY3RlcnMgaW4gdGhlIGZpcnN0IHR3byBjb2x1bW5zIGFyZToKCiAgICAgIENIQVIJTU9ERQl+CiAgICAgPFNwYWNlPglOb3JtYWwsIFZpc3VhbCwgU2VsZWN0IGFuZCBPcGVyYXRvci1wZW5kaW5nCgluCU5vcm1hbAoJdglWaXN1YWwgYW5kIFNlbGVjdAoJcwlTZWxlY3QKCXgJVmlzdWFsCglvCU9wZXJhdG9yLXBlbmRpbmcKCSEJSW5zZXJ0IGFuZCBDb21tYW5kLWxpbmUKCWkJSW5zZXJ0CglsCSI6bG1hcCIgbWFwcGluZ3MgZm9yIEluc2VydCwgQ29tbWFuZC1saW5lIGFuZCBMYW5nLUFyZwoJYwlDb21tYW5kLWxpbmUKCkp1c3QgYmVmb3JlIHRoZSB7cmhzfSBhIHNwZWNpYWwgY2hhcmFjdGVyIGNhbiBhcHBlYXI6CgkqCWluZGljYXRlcyB0aGF0IGl0IGlzIG5vdCByZW1hcHBhYmxlCgkmCWluZGljYXRlcyB0aGF0IG9ubHkgc2NyaXB0LWxvY2FsIG1hcHBpbmdzIGFyZSByZW1hcHBhYmxlCglACWluZGljYXRlcyBhIGJ1ZmZlci1sb2NhbCBtYXBwaW5nCgpFdmVyeXRoaW5nIGZyb20gdGhlIGZpcnN0IG5vbi1ibGFuayBhZnRlciB7bGhzfSB1cCB0byB0aGUgZW5kIG9mIHRoZSBsaW5lCihvciAnfCcpIGlzIGNvbnNpZGVyZWQgdG8gYmUgcGFydCBvZiB7cmhzfS4gIFRoaXMgYWxsb3dzIHRoZSB7cmhzfSB0byBlbmQKd2l0aCBhIHNwYWNlLgoKTm90ZTogV2hlbiB1c2luZyBtYXBwaW5ncyBmb3IgVmlzdWFsIG1vZGUsIHlvdSBjYW4gdXNlIHRoZSAiJzwiIG1hcmssIHdoaWNoCmlzIHRoZSBzdGFydCBvZiB0aGUgbGFzdCBzZWxlY3RlZCBWaXN1YWwgYXJlYSBpbiB0aGUgY3VycmVudCBidWZmZXIgfCc8fC4KCgkJCQkJCQkqOm1hcC12ZXJib3NlKgpXaGVuICd2ZXJib3NlJyBpcyBub24temVybywgbGlzdGluZyBhIGtleSBtYXAgd2lsbCBhbHNvIGRpc3BsYXkgd2hlcmUgaXQgd2FzCmxhc3QgZGVmaW5lZC4gIEV4YW1wbGU6ID4KCgk6dmVyYm9zZSBtYXAgPEMtVz4qCgluICA8Qy1XPiogICAgICAqIDxDLVc+PEMtUz4qCgkJTGFzdCBzZXQgZnJvbSAvaG9tZS9hYmNkLy52aW1yYwoKU2VlIHw6dmVyYm9zZS1jbWR8IGZvciBtb3JlIGluZm9ybWF0aW9uLgoKCjEuNSBNQVBQSU5HIFNQRUNJQUwgS0VZUwkJCQkqOm1hcC1zcGVjaWFsLWtleXMqCgpUaGVyZSBhcmUgdGhyZWUgd2F5cyB0byBtYXAgYSBzcGVjaWFsIGtleToKMS4gVGhlIFZpLWNvbXBhdGlibGUgbWV0aG9kOiBNYXAgdGhlIGtleSBjb2RlLiAgT2Z0ZW4gdGhpcyBpcyBhIHNlcXVlbmNlIHRoYXQKICAgc3RhcnRzIHdpdGggPEVzYz4uICBUbyBlbnRlciBhIG1hcHBpbmcgbGlrZSB0aGlzIHlvdSB0eXBlICI6bWFwICIgYW5kIHRoZW4KICAgeW91IGhhdmUgdG8gdHlwZSBDVFJMLVYgYmVmb3JlIGhpdHRpbmcgdGhlIGZ1bmN0aW9uIGtleS4gIE5vdGUgdGhhdCB3aGVuCiAgIHRoZSBrZXkgY29kZSBmb3IgdGhlIGtleSBpcyBpbiB0aGUgdGVybWNhcCAodGhlIHRfIG9wdGlvbnMpLCBpdCB3aWxsCiAgIGF1dG9tYXRpY2FsbHkgYmUgdHJhbnNsYXRlZCBpbnRvIHRoZSBpbnRlcm5hbCBjb2RlIGFuZCBiZWNvbWUgdGhlIHNlY29uZAogICB3YXkgb2YgbWFwcGluZyAodW5sZXNzIHRoZSAnaycgZmxhZyBpcyBpbmNsdWRlZCBpbiAnY3BvcHRpb25zJykuCjIuIFRoZSBzZWNvbmQgbWV0aG9kIGlzIHRvIHVzZSB0aGUgaW50ZXJuYWwgY29kZSBmb3IgdGhlIGZ1bmN0aW9uIGtleS4gIFRvCiAgIGVudGVyIHN1Y2ggYSBtYXBwaW5nIHR5cGUgQ1RSTC1LIGFuZCB0aGVuIGhpdCB0aGUgZnVuY3Rpb24ga2V5LCBvciB1c2UKICAgdGhlIGZvcm0gIiMxIiwgIiMyIiwgLi4gIiM5IiwgIiMwIiwgIjxVcD4iLCAiPFMtRG93bj4iLCAiPFMtRjc+IiwgZXRjLgogICAoc2VlIHRhYmxlIG9mIGtleXMgfGtleS1ub3RhdGlvbnwsIGFsbCBrZXlzIGZyb20gPFVwPiBjYW4gYmUgdXNlZCkuICBUaGUKICAgZmlyc3QgdGVuIGZ1bmN0aW9uIGtleXMgY2FuIGJlIGRlZmluZWQgaW4gdHdvIHdheXM6IEp1c3QgdGhlIG51bWJlciwgbGlrZQogICAiIzIiLCBhbmQgd2l0aCAiPEY+IiwgbGlrZSAiPEYyPiIuICBCb3RoIHN0YW5kIGZvciBmdW5jdGlvbiBrZXkgMi4gICIjMCIKICAgcmVmZXJzIHRvIGZ1bmN0aW9uIGtleSAxMCwgZGVmaW5lZCB3aXRoIG9wdGlvbiAndF9mMTAnLCB3aGljaCBtYXkgYmUKICAgZnVuY3Rpb24ga2V5IHplcm8gb24gc29tZSBrZXlib2FyZHMuICBUaGUgPD4gZm9ybSBjYW5ub3QgYmUgdXNlZCB3aGVuCiAgICdjcG9wdGlvbnMnIGluY2x1ZGVzIHRoZSAnPCcgZmxhZy4KMy4gVXNlIHRoZSB0ZXJtY2FwIGVudHJ5LCB3aXRoIHRoZSBmb3JtIDx0X3h4Piwgd2hlcmUgInh4IiBpcyB0aGUgbmFtZSBvZiB0aGUKICAgdGVybWNhcCBlbnRyeS4gIEFueSBzdHJpbmcgZW50cnkgY2FuIGJlIHVzZWQuICBGb3IgZXhhbXBsZTogPgogICAgIDptYXAgPHRfRjM+IEcKPCAgTWFwcyBmdW5jdGlvbiBrZXkgMTMgdG8gIkciLiAgVGhpcyBkb2VzIG5vdCB3b3JrIGlmICdjcG9wdGlvbnMnIGluY2x1ZGVzCiAgIHRoZSAnPCcgZmxhZy4KClRoZSBhZHZhbnRhZ2Ugb2YgdGhlIHNlY29uZCBhbmQgdGhpcmQgbWV0aG9kIGlzIHRoYXQgdGhlIG1hcHBpbmcgd2lsbCB3b3JrIG9uCmRpZmZlcmVudCB0ZXJtaW5hbHMgd2l0aG91dCBtb2RpZmljYXRpb24gKHRoZSBmdW5jdGlvbiBrZXkgd2lsbCBiZQp0cmFuc2xhdGVkIGludG8gdGhlIHNhbWUgaW50ZXJuYWwgY29kZSBvciB0aGUgYWN0dWFsIGtleSBjb2RlLCBubyBtYXR0ZXIgd2hhdAp0ZXJtaW5hbCB5b3UgYXJlIHVzaW5nLiAgVGhlIHRlcm1jYXAgbXVzdCBiZSBjb3JyZWN0IGZvciB0aGlzIHRvIHdvcmssIGFuZCB5b3UKbXVzdCB1c2UgdGhlIHNhbWUgbWFwcGluZ3MpLgoKREVUQUlMOiBWaW0gZmlyc3QgY2hlY2tzIGlmIGEgc2VxdWVuY2UgZnJvbSB0aGUga2V5Ym9hcmQgaXMgbWFwcGVkLiAgSWYgaXQKaXNuJ3QgdGhlIHRlcm1pbmFsIGtleSBjb2RlcyBhcmUgdHJpZWQgKHNlZSB8dGVybWluYWwtb3B0aW9uc3wpLiAgSWYgYQp0ZXJtaW5hbCBjb2RlIGlzIGZvdW5kIGl0IGlzIHJlcGxhY2VkIHdpdGggdGhlIGludGVybmFsIGNvZGUuICBUaGVuIHRoZSBjaGVjawpmb3IgYSBtYXBwaW5nIGlzIGRvbmUgYWdhaW4gKHNvIHlvdSBjYW4gbWFwIGFuIGludGVybmFsIGNvZGUgdG8gc29tZXRoaW5nCmVsc2UpLiAgV2hhdCBpcyB3cml0dGVuIGludG8gdGhlIHNjcmlwdCBmaWxlIGRlcGVuZHMgb24gd2hhdCBpcyByZWNvZ25pemVkLgpJZiB0aGUgdGVybWluYWwga2V5IGNvZGUgd2FzIHJlY29nbml6ZWQgYXMgYSBtYXBwaW5nIHRoZSBrZXkgY29kZSBpdHNlbGYgaXMKd3JpdHRlbiB0byB0aGUgc2NyaXB0IGZpbGUuICBJZiBpdCB3YXMgcmVjb2duaXplZCBhcyBhIHRlcm1pbmFsIGNvZGUgdGhlCmludGVybmFsIGNvZGUgaXMgd3JpdHRlbiB0byB0aGUgc2NyaXB0IGZpbGUuCgoKMS42IFNQRUNJQUwgQ0hBUkFDVEVSUwkJCQkJKjptYXAtc3BlY2lhbC1jaGFycyoKCQkJCQkJCSptYXBfYmFja3NsYXNoKgpOb3RlIHRoYXQgb25seSBDVFJMLVYgaXMgbWVudGlvbmVkIGhlcmUgYXMgYSBzcGVjaWFsIGNoYXJhY3RlciBmb3IgbWFwcGluZ3MKYW5kIGFiYnJldmlhdGlvbnMuICBXaGVuICdjcG9wdGlvbnMnIGRvZXMgbm90IGNvbnRhaW4gJ0InLCBhIGJhY2tzbGFzaCBjYW4KYWxzbyBiZSB1c2VkIGxpa2UgQ1RSTC1WLiAgVGhlIDw+IG5vdGF0aW9uIGNhbiBiZSBmdWxseSB1c2VkIHRoZW4gfDw+fC4gIEJ1dAp5b3UgY2Fubm90IHVzZSAiPEMtVj4iIGxpa2UgQ1RSTC1WIHRvIGVzY2FwZSB0aGUgc3BlY2lhbCBtZWFuaW5nIG9mIHdoYXQKZm9sbG93cy4KClRvIG1hcCBhIGJhY2tzbGFzaCwgb3IgdXNlIGEgYmFja3NsYXNoIGxpdGVyYWxseSBpbiB0aGUge3Joc30sIHRoZSBzcGVjaWFsCnNlcXVlbmNlICI8QnNsYXNoPiIgY2FuIGJlIHVzZWQuICBUaGlzIGF2b2lkcyB0aGUgbmVlZCB0byBkb3VibGUgYmFja3NsYXNoZXMKd2hlbiB1c2luZyBuZXN0ZWQgbWFwcGluZ3MuCgoJCQkJCQkJKm1hcF9DVFJMLUMqClVzaW5nIENUUkwtQyBpbiB0aGUge2xoc30gaXMgcG9zc2libGUsIGJ1dCBpdCB3aWxsIG9ubHkgd29yayB3aGVuIFZpbSBpcwp3YWl0aW5nIGZvciBhIGtleSwgbm90IHdoZW4gVmltIGlzIGJ1c3kgd2l0aCBzb21ldGhpbmcuICBXaGVuIFZpbSBpcyBidXN5CkNUUkwtQyBpbnRlcnJ1cHRzL2JyZWFrcyB0aGUgY29tbWFuZC4KV2hlbiB1c2luZyB0aGUgR1VJIHZlcnNpb24gb24gTVMtV2luZG93cyBDVFJMLUMgY2FuIGJlIG1hcHBlZCB0byBhbGxvdyBhIENvcHkKY29tbWFuZCB0byB0aGUgY2xpcGJvYXJkLiAgVXNlIENUUkwtQnJlYWsgdG8gaW50ZXJydXB0IFZpbS4KCgkJCQkJCQkqbWFwX3NwYWNlX2luX2xocyoKVG8gaW5jbHVkZSBhIHNwYWNlIGluIHtsaHN9IHByZWNlZGUgaXQgd2l0aCBhIENUUkwtViAodHlwZSB0d28gQ1RSTC1WcyBmb3IKZWFjaCBzcGFjZSkuCgkJCQkJCQkqbWFwX3NwYWNlX2luX3JocyoKSWYgeW91IHdhbnQgYSB7cmhzfSB0aGF0IHN0YXJ0cyB3aXRoIGEgc3BhY2UsIHVzZSAiPFNwYWNlPiIuICBUbyBiZSBmdWxseSBWaQpjb21wYXRpYmxlIChidXQgdW5yZWFkYWJsZSkgZG9uJ3QgdXNlIHRoZSB8PD58IG5vdGF0aW9uLCBwcmVjZWRlIHtyaHN9IHdpdGggYQpzaW5nbGUgQ1RSTC1WICh5b3UgaGF2ZSB0byB0eXBlIENUUkwtViB0d28gdGltZXMpLgoJCQkJCQkJKm1hcF9lbXB0eV9yaHMqCllvdSBjYW4gY3JlYXRlIGFuIGVtcHR5IHtyaHN9IGJ5IHR5cGluZyBub3RoaW5nIGFmdGVyIGEgc2luZ2xlIENUUkwtViAoeW91CmhhdmUgdG8gdHlwZSBDVFJMLVYgdHdvIHRpbWVzKS4gIFVuZm9ydHVuYXRlbHksIHlvdSBjYW5ub3QgZG8gdGhpcyBpbiBhIHZpbXJjCmZpbGUuCgkJCQkJCQkqPE5vcD4qCkFuIGVhc2llciB3YXkgdG8gZ2V0IGEgbWFwcGluZyB0aGF0IGRvZXNuJ3QgcHJvZHVjZSBhbnl0aGluZywgaXMgdG8gdXNlCiI8Tm9wPiIgZm9yIHRoZSB7cmhzfS4gIFRoaXMgb25seSB3b3JrcyB3aGVuIHRoZSB8PD58IG5vdGF0aW9uIGlzIGVuYWJsZWQuCkZvciBleGFtcGxlLCB0byBtYWtlIHN1cmUgdGhhdCBmdW5jdGlvbiBrZXkgOCBkb2VzIG5vdGhpbmcgYXQgYWxsOiA+Cgk6bWFwICA8Rjg+ICA8Tm9wPgoJOm1hcCEgPEY4PiAgPE5vcD4KPAoJCQkJCQkJKm1hcC1tdWx0aWJ5dGUqCkl0IGlzIHBvc3NpYmxlIHRvIG1hcCBtdWx0aWJ5dGUgY2hhcmFjdGVycywgYnV0IG9ubHkgdGhlIHdob2xlIGNoYXJhY3Rlci4gIFlvdQpjYW5ub3QgbWFwIHRoZSBmaXJzdCBieXRlIG9ubHkuICBUaGlzIHdhcyBkb25lIHRvIHByZXZlbnQgcHJvYmxlbXMgaW4gdGhpcwpzY2VuYXJpbzogPgoJOnNldCBlbmNvZGluZz1sYXRpbjEKCTppbWFwIDxNLUM+IGZvbwoJOnNldCBlbmNvZGluZz11dGYtOApUaGUgbWFwcGluZyBmb3IgPE0tQz4gaXMgZGVmaW5lZCB3aXRoIHRoZSBsYXRpbjEgZW5jb2RpbmcsIHJlc3VsdGluZyBpbiBhIDB4YzMKYnl0ZS4gIElmIHlvdSB0eXBlIHRoZSBjaGFyYWN0ZXIg4SAoMHhlMSA8TS1hPikgaW4gVVRGLTggZW5jb2RpbmcgdGhpcyBpcyB0aGUKdHdvIGJ5dGVzIDB4YzMgMHhhMS4gIFlvdSBkb24ndCB3YW50IHRoZSAweGMzIGJ5dGUgdG8gYmUgbWFwcGVkIHRoZW4gb3IKb3RoZXJ3aXNlIGl0IHdvdWxkIGJlIGltcG9zc2libGUgdG8gdHlwZSB0aGUg4SBjaGFyYWN0ZXIuCgoJCQkJCSo8TGVhZGVyPiogKm1hcGxlYWRlcioKVG8gZGVmaW5lIGEgbWFwcGluZyB3aGljaCB1c2VzIHRoZSAibWFwbGVhZGVyIiB2YXJpYWJsZSwgdGhlIHNwZWNpYWwgc3RyaW5nCiI8TGVhZGVyPiIgY2FuIGJlIHVzZWQuICBJdCBpcyByZXBsYWNlZCB3aXRoIHRoZSBzdHJpbmcgdmFsdWUgb2YgIm1hcGxlYWRlciIuCklmICJtYXBsZWFkZXIiIGlzIG5vdCBzZXQgb3IgZW1wdHksIGEgYmFja3NsYXNoIGlzIHVzZWQgaW5zdGVhZC4gIEV4YW1wbGU6ID4KCTptYXAgPExlYWRlcj5BICBvYW5vdGhlciBsaW5lPEVzYz4KV29ya3MgbGlrZTogPgoJOm1hcCBcQSAgb2Fub3RoZXIgbGluZTxFc2M+CkJ1dCBhZnRlcjogPgoJOmxldCBtYXBsZWFkZXIgPSAiLCIKSXQgd29ya3MgbGlrZTogPgoJOm1hcCAsQSAgb2Fub3RoZXIgbGluZTxFc2M+CgpOb3RlIHRoYXQgdGhlIHZhbHVlIG9mICJtYXBsZWFkZXIiIGlzIHVzZWQgYXQgdGhlIG1vbWVudCB0aGUgbWFwcGluZyBpcwpkZWZpbmVkLiAgQ2hhbmdpbmcgIm1hcGxlYWRlciIgYWZ0ZXIgdGhhdCBoYXMgbm8gZWZmZWN0IGZvciBhbHJlYWR5IGRlZmluZWQKbWFwcGluZ3MuCgoJCQkJCSo8TG9jYWxMZWFkZXI+KiAqbWFwbG9jYWxsZWFkZXIqCjxMb2NhbExlYWRlcj4gaXMganVzdCBsaWtlIDxMZWFkZXI+LCBleGNlcHQgdGhhdCBpdCB1c2VzICJtYXBsb2NhbGxlYWRlciIKaW5zdGVhZCBvZiAibWFwbGVhZGVyIi4gIDxMb2NhbExlYWRlcj4gaXMgdG8gYmUgdXNlZCBmb3IgbWFwcGluZ3Mgd2hpY2ggYXJlCmxvY2FsIHRvIGEgYnVmZmVyLiAgRXhhbXBsZTogPgogICAgICA6bWFwIDxidWZmZXI+IDxMb2NhbExlYWRlcj5BICBvYW5vdGhlciBsaW5lPEVzYz4KPApJbiBhIGdsb2JhbCBwbHVnaW4gPExlYWRlcj4gc2hvdWxkIGJlIHVzZWQgYW5kIGluIGEgZmlsZXR5cGUgcGx1Z2luCjxMb2NhbExlYWRlcj4uICAibWFwbGVhZGVyIiBhbmQgIm1hcGxvY2FsbGVhZGVyIiBjYW4gYmUgZXF1YWwuICBBbHRob3VnaCwgaWYKeW91IG1ha2UgdGhlbSBkaWZmZXJlbnQsIHRoZXJlIGlzIGEgc21hbGxlciBjaGFuY2Ugb2YgbWFwcGluZ3MgZnJvbSBnbG9iYWwKcGx1Z2lucyB0byBjbGFzaCB3aXRoIG1hcHBpbmdzIGZvciBmaWxldHlwZSBwbHVnaW5zLiAgRm9yIGV4YW1wbGUsIHlvdSBjb3VsZAprZWVwICJtYXBsZWFkZXIiIGF0IHRoZSBkZWZhdWx0IGJhY2tzbGFzaCwgYW5kIHNldCAibWFwbG9jYWxsZWFkZXIiIHRvIGFuCnVuZGVyc2NvcmUuCgoJCQkJCQkJKm1hcC08U0lEPioKSW4gYSBzY3JpcHQgdGhlIHNwZWNpYWwga2V5IG5hbWUgIjxTSUQ+IiBjYW4gYmUgdXNlZCB0byBkZWZpbmUgYSBtYXBwaW5nCnRoYXQncyBsb2NhbCB0byB0aGUgc2NyaXB0LiAgU2VlIHw8U0lEPnwgZm9yIGRldGFpbHMuCgoJCQkJCQkJKjxQbHVnPioKVGhlIHNwZWNpYWwga2V5IG5hbWUgIjxQbHVnPiIgY2FuIGJlIHVzZWQgZm9yIGFuIGludGVybmFsIG1hcHBpbmcsIHdoaWNoIGlzCm5vdCB0byBiZSBtYXRjaGVkIHdpdGggYW55IGtleSBzZXF1ZW5jZS4gIFRoaXMgaXMgdXNlZnVsIGluIHBsdWdpbnMKfHVzaW5nLTxQbHVnPnwuCgoJCQkJCQkJKjxDaGFyPiogKjxDaGFyLT4qClRvIG1hcCBhIGNoYXJhY3RlciBieSBpdHMgZGVjaW1hbCwgb2N0YWwgb3IgaGV4YWRlY2ltYWwgbnVtYmVyIHRoZSA8Q2hhcj4KY29uc3RydWN0IGNhbiBiZSB1c2VkOgoJPENoYXItMTIzPgljaGFyYWN0ZXIgMTIzCgk8Q2hhci0wMzM+CWNoYXJhY3RlciAyNwoJPENoYXItMHg3Zj4JY2hhcmFjdGVyIDEyNwoJPFMtQ2hhci0xMTQ+ICAgIGNoYXJhY3RlciAxMTQgKCdyJykgc2hpZnRlZCAoJ1InKQpUaGlzIGlzIHVzZWZ1bCB0byBzcGVjaWZ5IGEgKG11bHRpLWJ5dGUpIGNoYXJhY3RlciBpbiBhICdrZXltYXAnIGZpbGUuClVwcGVyIGFuZCBsb3dlcmNhc2UgZGlmZmVyZW5jZXMgYXJlIGlnbm9yZWQuCgoJCQkJCQkJKm1hcC1jb21tZW50cyoKSXQgaXMgbm90IHBvc3NpYmxlIHRvIHB1dCBhIGNvbW1lbnQgYWZ0ZXIgdGhlc2UgY29tbWFuZHMsIGJlY2F1c2UgdGhlICciJwpjaGFyYWN0ZXIgaXMgY29uc2lkZXJlZCB0byBiZSBwYXJ0IG9mIHRoZSB7bGhzfSBvciB7cmhzfS4KCgkJCQkJCQkqbWFwX2JhcioKU2luY2UgdGhlICd8JyBjaGFyYWN0ZXIgaXMgdXNlZCB0byBzZXBhcmF0ZSBhIG1hcCBjb21tYW5kIGZyb20gdGhlIG5leHQKY29tbWFuZCwgeW91IHdpbGwgaGF2ZSB0byBkbyBzb21ldGhpbmcgc3BlY2lhbCB0byBpbmNsdWRlICBhICd8JyBpbiB7cmhzfS4KVGhlcmUgYXJlIHRocmVlIG1ldGhvZHM6CiAgIHVzZQkgICAgIHdvcmtzIHdoZW4JCQkgICBleGFtcGxlCX4KICAgPEJhcj4gICAgICc8JyBpcyBub3QgaW4gJ2Nwb3B0aW9ucycJICAgOm1hcCBfbCA6IWxzIDxCYXI+IG1vcmVeTQogICBcfAkgICAgICdiJyBpcyBub3QgaW4gJ2Nwb3B0aW9ucycJICAgOm1hcCBfbCA6IWxzIFx8IG1vcmVeTQogICBeVnwJICAgICBhbHdheXMsIGluIFZpbSBhbmQgVmkJICAgOm1hcCBfbCA6IWxzIF5WfCBtb3JlXk0KCihoZXJlIF5WIHN0YW5kcyBmb3IgQ1RSTC1WOyB0byBnZXQgb25lIENUUkwtViB5b3UgaGF2ZSB0byB0eXBlIGl0IHR3aWNlOyB5b3UKY2Fubm90IHVzZSB0aGUgPD4gbm90YXRpb24gIjxDLVY+IiBoZXJlKS4KCkFsbCB0aHJlZSB3b3JrIHdoZW4geW91IHVzZSB0aGUgZGVmYXVsdCBzZXR0aW5nIGZvciAnY3BvcHRpb25zJy4KCldoZW4gJ2InIGlzIHByZXNlbnQgaW4gJ2Nwb3B0aW9ucycsICJcfCIgd2lsbCBiZSByZWNvZ25pemVkIGFzIGEgbWFwcGluZwplbmRpbmcgaW4gYSAnXCcgYW5kIHRoZW4gYW5vdGhlciBjb21tYW5kLiAgVGhpcyBpcyBWaSBjb21wYXRpYmxlLCBidXQKaWxsb2dpY2FsIHdoZW4gY29tcGFyZWQgdG8gb3RoZXIgY29tbWFuZHMuCgoJCQkJCQkJKm1hcF9yZXR1cm4qCldoZW4geW91IGhhdmUgYSBtYXBwaW5nIHRoYXQgY29udGFpbnMgYW4gRXggY29tbWFuZCwgeW91IG5lZWQgdG8gcHV0IGEgbGluZQp0ZXJtaW5hdG9yIGFmdGVyIGl0IHRvIGhhdmUgaXQgZXhlY3V0ZWQuICBUaGUgdXNlIG9mIDxDUj4gaXMgcmVjb21tZW5kZWQgZm9yCnRoaXMgKHNlZSB8PD58KS4gIEV4YW1wbGU6ID4KICAgOm1hcCAgX2xzICA6IWxzIC1sICU8Q1I+OmVjaG8gInRoZSBlbmQiPENSPgoKVG8gYXZvaWQgbWFwcGluZyBvZiB0aGUgY2hhcmFjdGVycyB5b3UgdHlwZSBpbiBpbnNlcnQgb3IgQ29tbWFuZC1saW5lIG1vZGUsCnR5cGUgYSBDVFJMLVYgZmlyc3QuICBUaGUgbWFwcGluZyBpbiBJbnNlcnQgbW9kZSBpcyBkaXNhYmxlZCBpZiB0aGUgJ3Bhc3RlJwpvcHRpb24gaXMgb24uCgpOb3RlIHRoYXQgd2hlbiBhbiBlcnJvciBpcyBlbmNvdW50ZXJlZCAodGhhdCBjYXVzZXMgYW4gZXJyb3IgbWVzc2FnZSBvciBiZWVwKQp0aGUgcmVzdCBvZiB0aGUgbWFwcGluZyBpcyBub3QgZXhlY3V0ZWQuICBUaGlzIGlzIFZpLWNvbXBhdGlibGUuCgpOb3RlIHRoYXQgdGhlIHNlY29uZCBjaGFyYWN0ZXIgKGFyZ3VtZW50KSBvZiB0aGUgY29tbWFuZHMgQHpadFRmRltdcm0nYCJ2CmFuZCBDVFJMLVggaXMgbm90IG1hcHBlZC4gIFRoaXMgd2FzIGRvbmUgdG8gYmUgYWJsZSB0byB1c2UgYWxsIHRoZSBuYW1lZApyZWdpc3RlcnMgYW5kIG1hcmtzLCBldmVuIHdoZW4gdGhlIGNvbW1hbmQgd2l0aCB0aGUgc2FtZSBuYW1lIGhhcyBiZWVuCm1hcHBlZC4KCgoxLjcgV0hBVCBLRVlTIFRPIE1BUAkJCQkJKm1hcC13aGljaC1rZXlzKgoKSWYgeW91IGFyZSBnb2luZyB0byBtYXAgc29tZXRoaW5nLCB5b3Ugd2lsbCBuZWVkIHRvIGNob29zZSB3aGljaCBrZXkocykgdG8gdXNlCmZvciB0aGUge2xoc30uICBZb3Ugd2lsbCBoYXZlIHRvIGF2b2lkIGtleXMgdGhhdCBhcmUgdXNlZCBmb3IgVmltIGNvbW1hbmRzLApvdGhlcndpc2UgeW91IHdvdWxkIG5vdCBiZSBhYmxlIHRvIHVzZSB0aG9zZSBjb21tYW5kcyBhbnltb3JlLiAgSGVyZSBhcmUgYSBmZXcKc3VnZ2VzdGlvbnM6Ci0gRnVuY3Rpb24ga2V5cyA8RjI+LCA8RjM+LCBldGMuLiAgQWxzbyB0aGUgc2hpZnRlZCBmdW5jdGlvbiBrZXlzIDxTLUYxPiwKICA8Uy1GMj4sIGV0Yy4gIE5vdGUgdGhhdCA8RjE+IGlzIGFscmVhZHkgdXNlZCBmb3IgdGhlIGhlbHAgY29tbWFuZC4KLSBNZXRhLWtleXMgKHdpdGggdGhlIEFMVCBrZXkgcHJlc3NlZCkuICBEZXBlbmRpbmcgb24geW91ciBrZXlib2FyZCBhY2NlbnRlZAogIGNoYXJhY3RlcnMgbWF5IGJlIHVzZWQgYXMgd2VsbC4gfDptYXAtYWx0LWtleXN8Ci0gVXNlIHRoZSAnXycgb3IgJywnIGNoYXJhY3RlciBhbmQgdGhlbiBhbnkgb3RoZXIgY2hhcmFjdGVyLiAgVGhlICJfIiBhbmQgIiwiCiAgY29tbWFuZHMgZG8gZXhpc3QgaW4gVmltIChzZWUgfF98IGFuZCB8LHwpLCBidXQgeW91IHByb2JhYmx5IG5ldmVyIHVzZSB0aGVtLgotIFVzZSBhIGtleSB0aGF0IGlzIGEgc3lub255bSBmb3IgYW5vdGhlciBjb21tYW5kLiAgRm9yIGV4YW1wbGU6IENUUkwtUCBhbmQKICBDVFJMLU4uICBVc2UgYW4gZXh0cmEgY2hhcmFjdGVyIHRvIGFsbG93IG1vcmUgbWFwcGluZ3MuCi0gVGhlIGtleSBkZWZpbmVkIGJ5IDxMZWFkZXI+IGFuZCBvbmUgb3IgbW9yZSBvdGhlciBrZXlzLiAgVGhpcyBpcyBlc3BlY2lhbGx5CiAgdXNlZnVsIGluIHNjcmlwdHMuIHxtYXBsZWFkZXJ8CgpTZWUgdGhlIGZpbGUgImluZGV4IiBmb3Iga2V5cyB0aGF0IGFyZSBub3QgdXNlZCBhbmQgdGh1cyBjYW4gYmUgbWFwcGVkIHdpdGhvdXQKbG9zaW5nIGFueSBidWlsdGluIGZ1bmN0aW9uLiAgWW91IGNhbiBhbHNvIHVzZSAiOmhlbHAge2tleX1eRCIgdG8gZmluZCBvdXQgaWYKYSBrZXkgaXMgdXNlZCBmb3Igc29tZSBjb21tYW5kLiAgKHtrZXl9IGlzIHRoZSBzcGVjaWZpYyBrZXkgeW91IHdhbnQgdG8gZmluZApvdXQgYWJvdXQsIF5EIGlzIENUUkwtRCkuCgoKMS44IEVYQU1QTEVTCQkJCQkJKm1hcC1leGFtcGxlcyoKCkEgZmV3IGV4YW1wbGVzIChnaXZlbiBhcyB5b3UgdHlwZSB0aGVtLCBmb3IgIjxDUj4iIHlvdSB0eXBlIGZvdXIgY2hhcmFjdGVyczsKdGhlICc8JyBmbGFnIG11c3Qgbm90IGJlIHByZXNlbnQgaW4gJ2Nwb3B0aW9ucycgZm9yIHRoaXMgdG8gd29yaykuID4KCiAgIDptYXAgPEYzPiAgbyNpbmNsdWRlCiAgIDptYXAgPE0tZz4gL2ZvbzxDUj5jd2JhcjxFc2M+CiAgIDptYXAgX3ggICAgZC9FTkQvZTxDUj4KICAgOm1hcCEgcXEgICBxdWFkcmlsbGlvbiBxdWVzdGlvbnMKCgpNdWx0aXBseWluZyBhIGNvdW50CgpXaGVuIHlvdSB0eXBlIGEgY291bnQgYmVmb3JlIHRyaWdnZXJpbmcgYSBtYXBwaW5nLCBpdCdzIGxpa2UgdGhlIGNvdW50IHdhcwp0eXBlZCBiZWZvcmUgdGhlIHtsaHN9LiAgRm9yIGV4YW1wbGUsIHdpdGggdGhpcyBtYXBwaW5nOiA+CiAgIDptYXAgPEY0PiAgM3cKVHlwaW5nIDI8RjQ+IHdpbGwgcmVzdWx0IGluICIyM3ciLiBUaHVzIG5vdCBtb3ZpbmcgMiAqIDMgd29yZHMgYnV0IDIzIHdvcmRzLgpJZiB5b3Ugd2FudCB0byBtdWx0aXBseSBjb3VudHMgdXNlIHRoZSBleHByZXNzaW9uIHJlZ2lzdGVyOiA+CiAgIDptYXAgPEY0PiAgQD0nM3cnPENSPgpUaGUgcGFydCBiZXR3ZWVuIHF1b3RlcyBpcyB0aGUgZXhwcmVzc2lvbiBiZWluZyBleGVjdXRlZC4gfEA9fAoKCjEuOSBVU0lORyBNQVBQSU5HUwkJCQkJKm1hcC10eXBpbmcqCgpWaW0gd2lsbCBjb21wYXJlIHdoYXQgeW91IHR5cGUgd2l0aCB0aGUgc3RhcnQgb2YgYSBtYXBwZWQgc2VxdWVuY2UuICBJZiB0aGVyZQppcyBhbiBpbmNvbXBsZXRlIG1hdGNoLCBpdCB3aWxsIGdldCBtb3JlIGNoYXJhY3RlcnMgdW50aWwgdGhlcmUgZWl0aGVyIGlzIGEKY29tcGxldGUgbWF0Y2ggb3IgdW50aWwgdGhlcmUgaXMgbm8gbWF0Y2ggYXQgYWxsLiAgRXhhbXBsZTogSWYgeW91IG1hcCEgInFxIiwKdGhlIGZpcnN0ICdxJyB3aWxsIG5vdCBhcHBlYXIgb24gdGhlIHNjcmVlbiB1bnRpbCB5b3UgdHlwZSBhbm90aGVyCmNoYXJhY3Rlci4gIFRoaXMgaXMgYmVjYXVzZSBWaW0gY2Fubm90IGtub3cgaWYgdGhlIG5leHQgY2hhcmFjdGVyIHdpbGwgYmUgYQoncScgb3Igbm90LiAgSWYgdGhlICd0aW1lb3V0JyBvcHRpb24gaXMgb24gKHdoaWNoIGlzIHRoZSBkZWZhdWx0KSBWaW0gd2lsbApvbmx5IHdhaXQgZm9yIG9uZSBzZWNvbmQgKG9yIGFzIGxvbmcgYXMgc3BlY2lmaWVkIHdpdGggdGhlICd0aW1lb3V0bGVuJwpvcHRpb24pLiAgQWZ0ZXIgdGhhdCBpdCBhc3N1bWVzIHRoYXQgdGhlICdxJyBpcyB0byBiZSBpbnRlcnByZXRlZCBhcyBzdWNoLiAgSWYKeW91IHR5cGUgc2xvd2x5LCBvciB5b3VyIHN5c3RlbSBpcyBzbG93LCByZXNldCB0aGUgJ3RpbWVvdXQnIG9wdGlvbi4gIFRoZW4geW91Cm1pZ2h0IHdhbnQgdG8gc2V0IHRoZSAndHRpbWVvdXQnIG9wdGlvbi4KCgkJCQkJCQkqbWFwLWtleXMtZmFpbHMqClRoZXJlIGFyZSBzaXR1YXRpb25zIHdoZXJlIGtleSBjb2RlcyBtaWdodCBub3QgYmUgcmVjb2duaXplZDoKLSBWaW0gY2FuIG9ubHkgcmVhZCBwYXJ0IG9mIHRoZSBrZXkgY29kZS4gIE1vc3RseSB0aGlzIGlzIG9ubHkgdGhlIGZpcnN0CiAgY2hhcmFjdGVyLiAgVGhpcyBoYXBwZW5zIG9uIHNvbWUgVW5peCB2ZXJzaW9ucyBpbiBhbiB4dGVybS4KLSBUaGUga2V5IGNvZGUgaXMgYWZ0ZXIgY2hhcmFjdGVyKHMpIHRoYXQgYXJlIG1hcHBlZC4gIEUuZy4sICI8RjE+PEYxPiIgb3IKICAiZzxGMT4iLgoKVGhlIHJlc3VsdCBpcyB0aGF0IHRoZSBrZXkgY29kZSBpcyBub3QgcmVjb2duaXplZCBpbiB0aGlzIHNpdHVhdGlvbiwgYW5kIHRoZQptYXBwaW5nIGZhaWxzLiAgVGhlcmUgYXJlIHR3byBhY3Rpb25zIG5lZWRlZCB0byBhdm9pZCB0aGlzIHByb2JsZW06CgotIFJlbW92ZSB0aGUgJ0snIGZsYWcgZnJvbSAnY3BvcHRpb25zJy4gIFRoaXMgd2lsbCBtYWtlIFZpbSB3YWl0IGZvciB0aGUgcmVzdAogIG9mIHRoZSBjaGFyYWN0ZXJzIG9mIHRoZSBmdW5jdGlvbiBrZXkuCi0gV2hlbiB1c2luZyA8RjE+IHRvIDxGND4gdGhlIGFjdHVhbCBrZXkgY29kZSBnZW5lcmF0ZWQgbWF5IGNvcnJlc3BvbmQgdG8KICA8eEYxPiB0byA8eEY0Pi4gIFRoZXJlIGFyZSBtYXBwaW5ncyBmcm9tIDx4RjE+IHRvIDxGMT4sIDx4RjI+IHRvIDxGMj4sIGV0Yy4sCiAgYnV0IHRoZXNlIGFyZSBub3QgcmVjb2duaXplZCBhZnRlciBhbm90aGVyIGhhbGYgYSBtYXBwaW5nLiAgTWFrZSBzdXJlIHRoZQogIGtleSBjb2RlcyBmb3IgPEYxPiB0byA8RjQ+IGFyZSBjb3JyZWN0OiA+Cgk6c2V0IDxGMT49PHR5cGUgQ1RSTC1WPjx0eXBlIEYxPgo8IFR5cGUgdGhlIDxGMT4gYXMgZm91ciBjaGFyYWN0ZXJzLiAgVGhlIHBhcnQgYWZ0ZXIgdGhlICI9IiBtdXN0IGJlIGRvbmUgd2l0aAogIHRoZSBhY3R1YWwga2V5cywgbm90IHRoZSBsaXRlcmFsIHRleHQuCkFub3RoZXIgc29sdXRpb24gaXMgdG8gdXNlIHRoZSBhY3R1YWwga2V5IGNvZGUgaW4gdGhlIG1hcHBpbmcgZm9yIHRoZSBzZWNvbmQKc3BlY2lhbCBrZXk6ID4KCTptYXAgPEYxPjxFc2M+T1AgOmVjaG8gInllcyI8Q1I+CkRvbid0IHR5cGUgYSByZWFsIDxFc2M+LCBWaW0gd2lsbCByZWNvZ25pemUgdGhlIGtleSBjb2RlIGFuZCByZXBsYWNlIGl0IHdpdGgKPEYxPiBhbnl3YXkuCgpBbm90aGVyIHByb2JsZW0gbWF5IGJlIHRoYXQgd2hlbiBrZWVwaW5nIEFMVCBvciBNZXRhIHByZXNzZWQgdGhlIHRlcm1pbmFsCnByZXBlbmRzIEVTQyBpbnN0ZWFkIG9mIHNldHRpbmcgdGhlIDh0aCBiaXQuICBTZWUgfDptYXAtYWx0LWtleXN8LgoKCQkJCQkJKnJlY3Vyc2l2ZV9tYXBwaW5nKgpJZiB5b3UgaW5jbHVkZSB0aGUge2xoc30gaW4gdGhlIHtyaHN9IHlvdSBoYXZlIGEgcmVjdXJzaXZlIG1hcHBpbmcuICBXaGVuCntsaHN9IGlzIHR5cGVkLCBpdCB3aWxsIGJlIHJlcGxhY2VkIHdpdGgge3Joc30uICBXaGVuIHRoZSB7bGhzfSB3aGljaCBpcwppbmNsdWRlZCBpbiB7cmhzfSBpcyBlbmNvdW50ZXJlZCBpdCB3aWxsIGJlIHJlcGxhY2VkIHdpdGgge3Joc30sIGFuZCBzbyBvbi4KVGhpcyBtYWtlcyBpdCBwb3NzaWJsZSB0byByZXBlYXQgYSBjb21tYW5kIGFuIGluZmluaXRlIG51bWJlciBvZiB0aW1lcy4gIFRoZQpvbmx5IHByb2JsZW0gaXMgdGhhdCB0aGUgb25seSB3YXkgdG8gc3RvcCB0aGlzIGlzIGJ5IGNhdXNpbmcgYW4gZXJyb3IuICBUaGUKbWFjcm9zIHRvIHNvbHZlIGEgbWF6ZSB1c2VzIHRoaXMsIGxvb2sgdGhlcmUgZm9yIGFuIGV4YW1wbGUuICBUaGVyZSBpcyBvbmUKZXhjZXB0aW9uOiBJZiB0aGUge3Joc30gc3RhcnRzIHdpdGgge2xoc30sIHRoZSBmaXJzdCBjaGFyYWN0ZXIgaXMgbm90IG1hcHBlZAphZ2FpbiAodGhpcyBpcyBWaSBjb21wYXRpYmxlKS4KRm9yIGV4YW1wbGU6ID4KICAgOm1hcCBhYiBhYmNkCndpbGwgZXhlY3V0ZSB0aGUgImEiIGNvbW1hbmQgYW5kIGluc2VydCAiYmNkIiBpbiB0aGUgdGV4dC4gIFRoZSAiYWIiIGluIHRoZQp7cmhzfSB3aWxsIG5vdCBiZSBtYXBwZWQgYWdhaW4uCgpJZiB5b3Ugd2FudCB0byBleGNoYW5nZSB0aGUgbWVhbmluZyBvZiB0d28ga2V5cyB5b3Ugc2hvdWxkIHVzZSB0aGUgOm5vcmVtYXAKY29tbWFuZC4gIEZvciBleGFtcGxlOiA+CiAgIDpub3JlbWFwIGsgagogICA6bm9yZW1hcCBqIGsKVGhpcyB3aWxsIGV4Y2hhbmdlIHRoZSBjdXJzb3IgdXAgYW5kIGRvd24gY29tbWFuZHMuCgpXaXRoIHRoZSBub3JtYWwgOm1hcCBjb21tYW5kLCB3aGVuIHRoZSAncmVtYXAnIG9wdGlvbiBpcyBvbiwgbWFwcGluZyB0YWtlcwpwbGFjZSB1bnRpbCB0aGUgdGV4dCBpcyBmb3VuZCBub3QgdG8gYmUgYSBwYXJ0IG9mIGEge2xoc30uICBGb3IgZXhhbXBsZSwgaWYKeW91IHVzZTogPgogICA6bWFwIHggeQogICA6bWFwIHkgeApWaW0gd2lsbCByZXBsYWNlIHggd2l0aCB5LCBhbmQgdGhlbiB5IHdpdGggeCwgZXRjLiAgV2hlbiB0aGlzIGhhcyBoYXBwZW5lZAonbWF4bWFwZGVwdGgnIHRpbWVzIChkZWZhdWx0IDEwMDApLCBWaW0gd2lsbCBnaXZlIHRoZSBlcnJvciBtZXNzYWdlCiJyZWN1cnNpdmUgbWFwcGluZyIuCgoJCQkJCQkJKjptYXAtdW5kbyoKSWYgeW91IGluY2x1ZGUgYW4gdW5kbyBjb21tYW5kIGluc2lkZSBhIG1hcHBlZCBzZXF1ZW5jZSwgdGhpcyB3aWxsIGJyaW5nIHRoZQp0ZXh0IGJhY2sgaW4gdGhlIHN0YXRlIGJlZm9yZSBleGVjdXRpbmcgdGhlIG1hY3JvLiAgVGhpcyBpcyBjb21wYXRpYmxlIHdpdGgKdGhlIG9yaWdpbmFsIFZpLCBhcyBsb25nIGFzIHRoZXJlIGlzIG9ubHkgb25lIHVuZG8gY29tbWFuZCBpbiB0aGUgbWFwcGVkCnNlcXVlbmNlIChoYXZpbmcgdHdvIHVuZG8gY29tbWFuZHMgaW4gYSBtYXBwZWQgc2VxdWVuY2UgZGlkIG5vdCBtYWtlIHNlbnNlCmluIHRoZSBvcmlnaW5hbCBWaSwgeW91IHdvdWxkIGdldCBiYWNrIHRoZSB0ZXh0IGJlZm9yZSB0aGUgZmlyc3QgdW5kbykuCgoKMS4xMCBNQVBQSU5HIEFMVC1LRVlTCQkJCQkqOm1hcC1hbHQta2V5cyoKCkluIHRoZSBHVUkgVmltIGhhbmRsZXMgdGhlIEFsdCBrZXkgaXRzZWxmLCB0aHVzIG1hcHBpbmcga2V5cyB3aXRoIEFMVCBzaG91bGQKYWx3YXlzIHdvcmsuICBCdXQgaW4gYSB0ZXJtaW5hbCBWaW0gZ2V0cyBhIHNlcXVlbmNlIG9mIGJ5dGVzIGFuZCBoYXMgdG8gZmlndXJlCm91dCB3aGV0aGVyIEFMVCB3YXMgcHJlc3NlZCBvciBub3QuCgpCeSBkZWZhdWx0IFZpbSBhc3N1bWVzIHRoYXQgcHJlc3NpbmcgdGhlIEFMVCBrZXkgc2V0cyB0aGUgOHRoIGJpdCBvZiBhIHR5cGVkCmNoYXJhY3Rlci4gIE1vc3QgZGVjZW50IHRlcm1pbmFscyBjYW4gd29yayB0aGF0IHdheSwgc3VjaCBhcyB4dGVybSwgYXRlcm0gYW5kCnJ4dnQuICBJZiB5b3VyIDxBLWs+IG1hcHBpbmdzIGRvbid0IHdvcmsgaXQgbWlnaHQgYmUgdGhhdCB0aGUgdGVybWluYWwgaXMKcHJlZml4aW5nIHRoZSBjaGFyYWN0ZXIgd2l0aCBhbiBFU0MgY2hhcmFjdGVyLiAgQnV0IHlvdSBjYW4ganVzdCBhcyB3ZWxsIHR5cGUKRVNDIGJlZm9yZSBhIGNoYXJhY3RlciwgdGh1cyBWaW0gZG9lc24ndCBrbm93IHdoYXQgaGFwcGVuZWQgKGV4Y2VwdCBmb3IKY2hlY2tpbmcgdGhlIGRlbGF5IGJldHdlZW4gY2hhcmFjdGVycywgd2hpY2ggaXMgbm90IHJlbGlhYmxlKS4KCkFzIG9mIHRoaXMgd3JpdGluZywgc29tZSBtYWluc3RyZWFtIHRlcm1pbmFscyBsaWtlIGdub21lLXRlcm1pbmFsIGFuZCBrb25zb2xlCnVzZSB0aGUgRVNDIHByZWZpeC4gIFRoZXJlIGRvZXNuJ3QgYXBwZWFyIGEgd2F5IHRvIGhhdmUgdGhlbSB1c2UgdGhlIDh0aCBiaXQKaW5zdGVhZC4gIFh0ZXJtIHNob3VsZCB3b3JrIHdlbGwgYnkgZGVmYXVsdC4gIEF0ZXJtIGFuZCByeHZ0IHNob3VsZCB3b3JrIHdlbGwKd2hlbiBzdGFydGVkIHdpdGggdGhlICItLW1ldGE4IiBhcmd1bWVudC4gIFlvdSBjYW4gYWxzbyB0d2VhayByZXNvdXJjZXMgbGlrZQoibWV0YVNlbmRzRXNjYXBlIiwgImVpZ2h0Qml0SW5wdXQiIGFuZCAiZWlnaHRCaXRPdXRwdXQiLgoKT24gdGhlIExpbnV4IGNvbnNvbGUsIHRoaXMgYmVoYXZpb3IgY2FuIGJlIHRvZ2dsZWQgd2l0aCB0aGUgInNldG1ldGFtb2RlIgpjb21tYW5kLiAgQmVhciBpbiBtaW5kIHRoYXQgbm90IHVzaW5nIGFuIEVTQyBwcmVmaXggY291bGQgZ2V0IHlvdSBpbiB0cm91YmxlCndpdGggb3RoZXIgcHJvZ3JhbXMuICBZb3Ugc2hvdWxkIG1ha2Ugc3VyZSB0aGF0IGJhc2ggaGFzIHRoZSAiY29udmVydC1tZXRhIgpvcHRpb24gc2V0IHRvICJvbiIgaW4gb3JkZXIgZm9yIHlvdXIgTWV0YSBrZXliaW5kaW5ncyB0byBzdGlsbCB3b3JrIG9uIGl0CihpdCdzIHRoZSBkZWZhdWx0IHJlYWRsaW5lIGJlaGF2aW9yLCB1bmxlc3MgY2hhbmdlZCBieSBzcGVjaWZpYyBzeXN0ZW0KY29uZmlndXJhdGlvbikuICBGb3IgdGhhdCwgeW91IGNhbiBhZGQgdGhlIGxpbmU6ID4KCglzZXQgY29udmVydC1tZXRhIG9uCgp0byB5b3VyIH4vLmlucHV0cmMgZmlsZS4gSWYgeW91J3JlIGNyZWF0aW5nIHRoZSBmaWxlLCB5b3UgbWlnaHQgd2FudCB0byB1c2U6ID4KCgkkaW5jbHVkZSAvZXRjL2lucHV0cmMKCmFzIHRoZSBmaXJzdCBsaW5lLCBpZiB0aGF0IGZpbGUgZXhpc3RzIG9uIHlvdXIgc3lzdGVtLCB0byBrZWVwIGdsb2JhbCBvcHRpb25zLgpUaGlzIG1heSBjYXVzZSBhIHByb2JsZW0gZm9yIGVudGVyaW5nIHNwZWNpYWwgY2hhcmFjdGVycywgc3VjaCBhcyB0aGUgdW1sYXV0LgpUaGVuIHlvdSBzaG91bGQgdXNlIENUUkwtViBiZWZvcmUgdGhhdCBjaGFyYWN0ZXIuCgpCZWFyIGluIG1pbmQgdGhhdCBjb252ZXJ0LW1ldGEgaGFzIGJlZW4gcmVwb3J0ZWQgdG8gaGF2ZSB0cm91YmxlcyB3aGVuIHVzZWQgaW4KVVRGLTggbG9jYWxlcy4gIE9uIHRlcm1pbmFscyBsaWtlIHh0ZXJtLCB0aGUgIm1ldGFTZW5kc0VzY2FwZSIgcmVzb3VyY2UgY2FuIGJlCnRvZ2dsZWQgb24gdGhlIGZseSB0aHJvdWdoIHRoZSAiTWFpbiBPcHRpb25zIiBtZW51LCBieSBwcmVzc2luZyBDdHJsLUxlZnRDbGljawpvbiB0aGUgdGVybWluYWw7IHRoYXQncyBhIGdvb2QgbGFzdCByZXNvdXJjZSBpbiBjYXNlIHlvdSB3YW50IHRvIHNlbmQgRVNDIHdoZW4KdXNpbmcgb3RoZXIgYXBwbGljYXRpb25zIGJ1dCBub3Qgd2hlbiBpbnNpZGUgVklNLgoKCjEuMTEgTUFQUElORyBBTiBPUEVSQVRPUgkJCQkqOm1hcC1vcGVyYXRvcioKCkFuIG9wZXJhdG9yIGlzIHVzZWQgYmVmb3JlIGEge21vdGlvbn0gY29tbWFuZC4gIFRvIGRlZmluZSB5b3VyIG93biBvcGVyYXRvcgp5b3UgbXVzdCBjcmVhdGUgbWFwcGluZyB0aGF0IGZpcnN0IHNldHMgdGhlICdvcGVyYXRvcmZ1bmMnIG9wdGlvbiBhbmQgdGhlbgppbnZva2UgdGhlIHxnQHwgb3BlcmF0b3IuICBBZnRlciB0aGUgdXNlciB0eXBlcyB0aGUge21vdGlvbn0gY29tbWFuZCB0aGUKc3BlY2lmaWVkIGZ1bmN0aW9uIHdpbGwgYmUgY2FsbGVkLgoKCQkJCQkJCSpnQCogKkU3NzQqICpFNzc1KgpnQHttb3Rpb259CQlDYWxsIHRoZSBmdW5jdGlvbiBzZXQgYnkgdGhlICdvcGVyYXRvcmZ1bmMnIG9wdGlvbi4KCQkJVGhlICdbIG1hcmsgaXMgcG9zaXRpb25lZCBhdCB0aGUgc3RhcnQgb2YgdGhlIHRleHQKCQkJbW92ZWQgb3ZlciBieSB7bW90aW9ufSwgdGhlICddIG1hcmsgb24gdGhlIGxhc3QKCQkJY2hhcmFjdGVyIG9mIHRoZSB0ZXh0LgoJCQlUaGUgZnVuY3Rpb24gaXMgY2FsbGVkIHdpdGggb25lIFN0cmluZyBhcmd1bWVudDoKCQkJICAgICJsaW5lIgl7bW90aW9ufSB3YXMgfGxpbmV3aXNlfAoJCQkgICAgImNoYXIiCXttb3Rpb259IHdhcyB8Y2hhcmFjdGVyd2lzZXwKCQkJICAgICJibG9jayIJe21vdGlvbn0gd2FzIHxibG9ja3dpc2UtdmlzdWFsfAoJCQlBbHRob3VnaCAiYmxvY2siIHdvdWxkIHJhcmVseSBhcHBlYXIsIHNpbmNlIGl0IGNhbgoJCQlvbmx5IHJlc3VsdCBmcm9tIFZpc3VhbCBtb2RlIHdoZXJlICJnQCIgaXMgbm90IHVzZWZ1bC4KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2V2YWx8CgkJCWZlYXR1cmV9CgpIZXJlIGlzIGFuIGV4YW1wbGUgdGhhdCBjb3VudHMgdGhlIG51bWJlciBvZiBzcGFjZXMgd2l0aCA8RjQ+OiA+CgoJbm1hcCA8c2lsZW50PiA8RjQ+IDpzZXQgb3BmdW5jPUNvdW50U3BhY2VzPENSPmdACgl2bWFwIDxzaWxlbnQ+IDxGND4gOjxDLVU+Y2FsbCBDb3VudFNwYWNlcyh2aXN1YWxtb2RlKCksIDEpPENSPgoKCWZ1bmN0aW9uISBDb3VudFNwYWNlcyh0eXBlLCAuLi4pCgkgIGxldCBzZWxfc2F2ZSA9ICZzZWxlY3Rpb24KCSAgbGV0ICZzZWxlY3Rpb24gPSAiaW5jbHVzaXZlIgoJICBsZXQgcmVnX3NhdmUgPSBAQAoKCSAgaWYgYTowICAiIEludm9rZWQgZnJvbSBWaXN1YWwgbW9kZSwgdXNlICc8IGFuZCAnPiBtYXJrcy4KCSAgICBzaWxlbnQgZXhlICJub3JtYWwhIGA8IiAuIGE6dHlwZSAuICJgPnkiCgkgIGVsc2VpZiBhOnR5cGUgPT0gJ2xpbmUnCgkgICAgc2lsZW50IGV4ZSAibm9ybWFsISAnW1YnXXkiCgkgIGVsc2VpZiBhOnR5cGUgPT0gJ2Jsb2NrJwoJICAgIHNpbGVudCBleGUgIm5vcm1hbCEgYFtcPEMtVj5gXXkiCgkgIGVsc2UKCSAgICBzaWxlbnQgZXhlICJub3JtYWwhIGBbdmBdeSIKCSAgZW5kaWYKCgkgIGVjaG9tc2cgc3RybGVuKHN1YnN0aXR1dGUoQEAsICdbXiBdJywgJycsICdnJykpCgoJICBsZXQgJnNlbGVjdGlvbiA9IHNlbF9zYXZlCgkgIGxldCBAQCA9IHJlZ19zYXZlCgllbmRmdW5jdGlvbgoKTm90ZSB0aGF0IHRoZSAnc2VsZWN0aW9uJyBvcHRpb24gaXMgdGVtcG9yYXJpbHkgc2V0IHRvICJpbmNsdXNpdmUiIHRvIGJlIGFibGUKdG8geWFuayBleGFjdGx5IHRoZSByaWdodCB0ZXh0IGJ5IHVzaW5nIFZpc3VhbCBtb2RlIGZyb20gdGhlICdbIHRvIHRoZSAnXQptYXJrLgoKQWxzbyBub3RlIHRoYXQgdGhlcmUgaXMgYSBzZXBhcmF0ZSBtYXBwaW5nIGZvciBWaXN1YWwgbW9kZS4gIEl0IHJlbW92ZXMgdGhlCiInPCwnPiIgcmFuZ2UgdGhhdCAiOiIgaW5zZXJ0cyBpbiBWaXN1YWwgbW9kZSBhbmQgaW52b2tlcyB0aGUgZnVuY3Rpb24gd2l0aAp2aXN1YWxtb2RlKCkgYW5kIGFuIGV4dHJhIGFyZ3VtZW50LgoKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CjIuIEFiYnJldmlhdGlvbnMJCQkqYWJicmV2aWF0aW9ucyogKkFiYnJldmlhdGlvbnMqCgpBYmJyZXZpYXRpb25zIGFyZSB1c2VkIGluIEluc2VydCBtb2RlLCBSZXBsYWNlIG1vZGUgYW5kIENvbW1hbmQtbGluZSBtb2RlLgpJZiB5b3UgZW50ZXIgYSB3b3JkIHRoYXQgaXMgYW4gYWJicmV2aWF0aW9uLCBpdCBpcyByZXBsYWNlZCB3aXRoIHRoZSB3b3JkIGl0CnN0YW5kcyBmb3IuICBUaGlzIGNhbiBiZSB1c2VkIHRvIHNhdmUgdHlwaW5nIGZvciBvZnRlbiB1c2VkIGxvbmcgd29yZHMuICBBbmQKeW91IGNhbiB1c2UgaXQgdG8gYXV0b21hdGljYWxseSBjb3JyZWN0IG9idmlvdXMgc3BlbGxpbmcgZXJyb3JzLgpFeGFtcGxlczoKCgk6aWFiIG1zIE1pY3Jvc29mdAoJOmlhYiB0aWhzIHRoaXMKClRoZXJlIGFyZSB0aHJlZSB0eXBlcyBvZiBhYmJyZXZpYXRpb25zOgoKZnVsbC1pZAkgIFRoZSAiZnVsbC1pZCIgdHlwZSBjb25zaXN0cyBlbnRpcmVseSBvZiBrZXl3b3JkIGNoYXJhY3RlcnMgKGxldHRlcnMKCSAgYW5kIGNoYXJhY3RlcnMgZnJvbSAnaXNrZXl3b3JkJyBvcHRpb24pLiAgVGhpcyBpcyB0aGUgbW9zdCBjb21tb24KCSAgYWJicmV2aWF0aW9uLgoKCSAgRXhhbXBsZXM6ICJmb28iLCAiZzMiLCAiLTEiCgplbmQtaWQJICBUaGUgImVuZC1pZCIgdHlwZSBlbmRzIGluIGEga2V5d29yZCBjaGFyYWN0ZXIsIGJ1dCBhbGwgdGhlIG90aGVyCgkgIGNoYXJhY3RlcnMgYXJlIG5vdCBrZXl3b3JkIGNoYXJhY3RlcnMuCgoJICBFeGFtcGxlczogIiNpIiwgIi4uZiIsICIkLzciCgpub24taWQJICBUaGUgIm5vbi1pZCIgdHlwZSBlbmRzIGluIGEgbm9uLWtleXdvcmQgY2hhcmFjdGVyLCB0aGUgb3RoZXIKCSAgY2hhcmFjdGVycyBtYXkgYmUgb2YgYW55IHR5cGUsIGV4Y2x1ZGluZyBzcGFjZSBhbmQgdGFiLiAge3RoaXMgdHlwZQoJICBpcyBub3Qgc3VwcG9ydGVkIGJ5IFZpfQoKCSAgRXhhbXBsZXM6ICJkZWYjIiwgIjQvNyQiCgpFeGFtcGxlcyBvZiBzdHJpbmdzIHRoYXQgY2Fubm90IGJlIGFiYnJldmlhdGlvbnM6ICJhLmIiLCAiI2RlZiIsICJhIGIiLCAiXyRyIgoKQW4gYWJicmV2aWF0aW9uIGlzIG9ubHkgcmVjb2duaXplZCB3aGVuIHlvdSB0eXBlIGEgbm9uLWtleXdvcmQgY2hhcmFjdGVyLgpUaGlzIGNhbiBhbHNvIGJlIHRoZSA8RXNjPiB0aGF0IGVuZHMgaW5zZXJ0IG1vZGUgb3IgdGhlIDxDUj4gdGhhdCBlbmRzIGEKY29tbWFuZC4gIFRoZSBub24ta2V5d29yZCBjaGFyYWN0ZXIgd2hpY2ggZW5kcyB0aGUgYWJicmV2aWF0aW9uIGlzIGluc2VydGVkCmFmdGVyIHRoZSBleHBhbmRlZCBhYmJyZXZpYXRpb24uICBBbiBleGNlcHRpb24gdG8gdGhpcyBpcyB0aGUgY2hhcmFjdGVyIDxDLV0+LAp3aGljaCBpcyB1c2VkIHRvIGV4cGFuZCBhbiBhYmJyZXZpYXRpb24gd2l0aG91dCBpbnNlcnRpbmcgYW55IGV4dHJhCmNoYXJhY3RlcnMuCgpFeGFtcGxlOiA+CiAgIDphYiBoaAloZWxsbwo8CSAgICAiaGg8U3BhY2U+IiBpcyBleHBhbmRlZCB0byAiaGVsbG88U3BhY2U+IgoJICAgICJoaDxDLV0+IiBpcyBleHBhbmRlZCB0byAiaGVsbG8iCgpUaGUgY2hhcmFjdGVycyBiZWZvcmUgdGhlIGN1cnNvciBtdXN0IG1hdGNoIHRoZSBhYmJyZXZpYXRpb24uICBFYWNoIHR5cGUgaGFzCmFuIGFkZGl0aW9uYWwgcnVsZToKCmZ1bGwtaWQJICBJbiBmcm9udCBvZiB0aGUgbWF0Y2ggaXMgYSBub24ta2V5d29yZCBjaGFyYWN0ZXIsIG9yIHRoaXMgaXMgd2hlcmUKCSAgdGhlIGxpbmUgb3IgaW5zZXJ0aW9uIHN0YXJ0cy4gIEV4Y2VwdGlvbjogV2hlbiB0aGUgYWJicmV2aWF0aW9uIGlzCgkgIG9ubHkgb25lIGNoYXJhY3RlciwgaXQgaXMgbm90IHJlY29nbml6ZWQgaWYgdGhlcmUgaXMgYSBub24ta2V5d29yZAoJICBjaGFyYWN0ZXIgaW4gZnJvbnQgb2YgaXQsIG90aGVyIHRoYW4gYSBzcGFjZSBvciBhIHRhYi4KCmVuZC1pZAkgIEluIGZyb250IG9mIHRoZSBtYXRjaCBpcyBhIGtleXdvcmQgY2hhcmFjdGVyLCBvciBhIHNwYWNlIG9yIGEgdGFiLAoJICBvciB0aGlzIGlzIHdoZXJlIHRoZSBsaW5lIG9yIGluc2VydGlvbiBzdGFydHMuCgpub24taWQJICBJbiBmcm9udCBvZiB0aGUgbWF0Y2ggaXMgYSBzcGFjZSwgdGFiIG9yIHRoZSBzdGFydCBvZiB0aGUgbGluZSBvcgoJICB0aGUgaW5zZXJ0aW9uLgoKRXhhbXBsZXM6ICh7Q1VSU09SfSBpcyB3aGVyZSB5b3UgdHlwZSBhIG5vbi1rZXl3b3JkIGNoYXJhY3RlcikgPgogICA6YWIgZm9vICAgZm91ciBvbGQgb3R0ZXJzCjwJCSIgZm9ve0NVUlNPUn0iCSAgaXMgZXhwYW5kZWQgdG8gIiBmb3VyIG9sZCBvdHRlcnMiCgkJIiBmb29iYXJ7Q1VSU09SfSIgaXMgbm90IGV4cGFuZGVkCgkJImJhcmZvb3tDVVJTT1J9IiAgaXMgbm90IGV4cGFuZGVkCj4KICAgOmFiICNpICNpbmNsdWRlCjwJCSIjaXtDVVJTT1J9IgkgIGlzIGV4cGFuZGVkIHRvICIjaW5jbHVkZSIKCQkiPiNpe0NVUlNPUn0iCSAgaXMgbm90IGV4cGFuZGVkCj4KICAgOmFiIDs7IDxlbmRvZmxpbmU+CjwJCSJ0ZXN0OzsiCSAgaXMgbm90IGV4cGFuZGVkCgkJInRlc3QgOzsiCSAgaXMgZXhwYW5kZWQgdG8gInRlc3QgPGVuZG9mbGluZT4iCgpUbyBhdm9pZCB0aGUgYWJicmV2aWF0aW9uIGluIGluc2VydCBtb2RlOiBUeXBlIHBhcnQgb2YgdGhlIGFiYnJldmlhdGlvbiwgZXhpdAppbnNlcnQgbW9kZSB3aXRoIDxFc2M+LCByZS1lbnRlciBpbnNlcnQgbW9kZSB3aXRoICJhIiBhbmQgdHlwZSB0aGUgcmVzdC4gIE9yCnR5cGUgQ1RSTC1WIGJlZm9yZSB0aGUgY2hhcmFjdGVyIGFmdGVyIHRoZSBhYmJyZXZpYXRpb24uClRvIGF2b2lkIHRoZSBhYmJyZXZpYXRpb24gaW4gQ29tbWFuZC1saW5lIG1vZGU6IFR5cGUgQ1RSTC1WIHR3aWNlIHNvbWV3aGVyZSBpbgp0aGUgYWJicmV2aWF0aW9uIHRvIGF2b2lkIGl0IHRvIGJlIHJlcGxhY2VkLiAgQSBDVFJMLVYgaW4gZnJvbnQgb2YgYSBub3JtYWwKY2hhcmFjdGVyIGlzIG1vc3RseSBpZ25vcmVkIG90aGVyd2lzZS4KCkl0IGlzIHBvc3NpYmxlIHRvIG1vdmUgdGhlIGN1cnNvciBhZnRlciBhbiBhYmJyZXZpYXRpb246ID4KICAgOmlhYiBpZiBpZiAoKTxMZWZ0PgpUaGlzIGRvZXMgbm90IHdvcmsgaWYgJ2Nwb3B0aW9ucycgaW5jbHVkZXMgdGhlICc8JyBmbGFnLiB8PD58CgpZb3UgY2FuIGV2ZW4gZG8gbW9yZSBjb21wbGljYXRlZCB0aGluZ3MuICBGb3IgZXhhbXBsZSwgdG8gY29uc3VtZSB0aGUgc3BhY2UKdHlwZWQgYWZ0ZXIgYW4gYWJicmV2aWF0aW9uOiA+CiAgIGZ1bmMgRWF0Y2hhcihwYXQpCiAgICAgIGxldCBjID0gbnIyY2hhcihnZXRjaGFyKDApKQogICAgICByZXR1cm4gKGMgPX4gYTpwYXQpID8gJycgOiBjCiAgIGVuZGZ1bmMKICAgaWFiYnIgPHNpbGVudD4gaWYgaWYgKCk8TGVmdD48Qy1SPj1FYXRjaGFyKCdccycpPENSPgoKVGhlcmUgYXJlIG5vIGRlZmF1bHQgYWJicmV2aWF0aW9ucy4KCkFiYnJldmlhdGlvbnMgYXJlIG5ldmVyIHJlY3Vyc2l2ZS4gIFlvdSBjYW4gdXNlICI6YWIgZiBmLW8tbyIgd2l0aG91dCBhbnkKcHJvYmxlbS4gIEJ1dCBhYmJyZXZpYXRpb25zIGNhbiBiZSBtYXBwZWQuICB7c29tZSB2ZXJzaW9ucyBvZiBWaSBzdXBwb3J0CnJlY3Vyc2l2ZSBhYmJyZXZpYXRpb25zLCBmb3Igbm8gYXBwYXJlbnQgcmVhc29ufQoKQWJicmV2aWF0aW9ucyBhcmUgZGlzYWJsZWQgaWYgdGhlICdwYXN0ZScgb3B0aW9uIGlzIG9uLgoKCQkJCSo6YWJicmV2aWF0ZS1sb2NhbCogKjphYmJyZXZpYXRlLTxidWZmZXI+KgpKdXN0IGxpa2UgbWFwcGluZ3MsIGFiYnJldmlhdGlvbnMgY2FuIGJlIGxvY2FsIHRvIGEgYnVmZmVyLiAgVGhpcyBpcyBtb3N0bHkKdXNlZCBpbiBhIHxmaWxldHlwZS1wbHVnaW58IGZpbGUuICBFeGFtcGxlIGZvciBhIEMgcGx1Z2luIGZpbGU6ID4KCTphYmIgPGJ1ZmZlcj4gRkYgIGZvciAoaSA9IDA7IGkgPCA7ICsraSkKPAoJCQkJCQkqOmFiKiAqOmFiYnJldmlhdGUqCjphYlticmV2aWF0ZV0JCWxpc3QgYWxsIGFiYnJldmlhdGlvbnMuICBUaGUgY2hhcmFjdGVyIGluIHRoZSBmaXJzdAoJCQljb2x1bW4gaW5kaWNhdGVzIHRoZSBtb2RlIHdoZXJlIHRoZSBhYmJyZXZpYXRpb24gaXMKCQkJdXNlZDogJ2knIGZvciBpbnNlcnQgbW9kZSwgJ2MnIGZvciBDb21tYW5kLWxpbmUKCQkJbW9kZSwgJyEnIGZvciBib3RoLiAgVGhlc2UgYXJlIHRoZSBzYW1lIGFzIGZvcgoJCQltYXBwaW5ncywgc2VlIHxtYXAtbGlzdGluZ3wuCgoJCQkJCQkqOmFiYnJldmlhdGUtdmVyYm9zZSoKV2hlbiAndmVyYm9zZScgaXMgbm9uLXplcm8sIGxpc3RpbmcgYW4gYWJicmV2aWF0aW9uIHdpbGwgYWxzbyBkaXNwbGF5IHdoZXJlIGl0CndhcyBsYXN0IGRlZmluZWQuICBFeGFtcGxlOiA+CgoJOnZlcmJvc2UgYWJicmV2aWF0ZQoJISAgdGVoCQkgdGhlCgkJTGFzdCBzZXQgZnJvbSAvaG9tZS9hYmNkL3ZpbS9hYmJyLnZpbQoKU2VlIHw6dmVyYm9zZS1jbWR8IGZvciBtb3JlIGluZm9ybWF0aW9uLgoKOmFiW2JyZXZpYXRlXSB7bGhzfQlsaXN0IHRoZSBhYmJyZXZpYXRpb25zIHRoYXQgc3RhcnQgd2l0aCB7bGhzfQoJCQlZb3UgbWF5IG5lZWQgdG8gaW5zZXJ0IGEgQ1RSTC1WICh0eXBlIGl0IHR3aWNlKSB0bwoJCQlhdm9pZCB0aGF0IGEgdHlwZWQge2xoc30gaXMgZXhwYW5kZWQsIHNpbmNlCgkJCWNvbW1hbmQtbGluZSBhYmJyZXZpYXRpb25zIGFwcGx5IGhlcmUuCgo6YWJbYnJldmlhdGVdIFs8ZXhwcj5dIFs8YnVmZmVyPl0ge2xoc30ge3Joc30KCQkJYWRkIGFiYnJldmlhdGlvbiBmb3Ige2xoc30gdG8ge3Joc30uICBJZiB7bGhzfSBhbHJlYWR5CgkJCWV4aXN0ZWQgaXQgaXMgcmVwbGFjZWQgd2l0aCB0aGUgbmV3IHtyaHN9LiAge3Joc30gbWF5CgkJCWNvbnRhaW4gc3BhY2VzLgoJCQlTZWUgfDptYXAtPGV4cHI+fCBmb3IgdGhlIG9wdGlvbmFsIDxleHByPiBhcmd1bWVudC4KCQkJU2VlIHw6bWFwLTxidWZmZXI+fCBmb3IgdGhlIG9wdGlvbmFsIDxidWZmZXI+IGFyZ3VtZW50LgoKCQkJCQkJKjp1bmEqICo6dW5hYmJyZXZpYXRlKgo6dW5hW2JicmV2aWF0ZV0ge2xoc30JUmVtb3ZlIGFiYnJldmlhdGlvbiBmb3Ige2xoc30gZnJvbSB0aGUgbGlzdC4gIElmIG5vbmUKCQkJaXMgZm91bmQsIHJlbW92ZSBhYmJyZXZpYXRpb25zIGluIHdoaWNoIHtsaHN9IG1hdGNoZXMKCQkJd2l0aCB0aGUge3Joc30uICBUaGlzIGlzIGRvbmUgc28gdGhhdCB5b3UgY2FuIGV2ZW4KCQkJcmVtb3ZlIGFiYnJldmlhdGlvbnMgYWZ0ZXIgZXhwYW5zaW9uLiAgVG8gYXZvaWQKCQkJZXhwYW5zaW9uIGluc2VydCBhIENUUkwtViAodHlwZSBpdCB0d2ljZSkuCgoJCQkJCQkqOm5vcmVhKiAqOm5vcmVhYmJyZXYqCjpub3JlYVtiYnJldl0gWzxleHByPl0gWzxidWZmZXI+XSBbbGhzXSBbcmhzXQoJCQlzYW1lIGFzICI6YWIiLCBidXQgbm8gcmVtYXBwaW5nIGZvciB0aGlzIHtyaHN9IHtub3QKCQkJaW4gVml9CgoJCQkJCQkqOmNhKiAqOmNhYmJyZXYqCjpjYVtiYnJldl0gWzxleHByPl0gWzxidWZmZXI+XSBbbGhzXSBbcmhzXQoJCQlzYW1lIGFzICI6YWIiLCBidXQgZm9yIENvbW1hbmQtbGluZSBtb2RlIG9ubHkuICB7bm90CgkJCWluIFZpfQoKCQkJCQkJKjpjdW5hKiAqOmN1bmFiYnJldioKOmN1bmFbYmJyZXZdIHtsaHN9CXNhbWUgYXMgIjp1bmEiLCBidXQgZm9yIENvbW1hbmQtbGluZSBtb2RlIG9ubHkuICB7bm90CgkJCWluIFZpfQoKCQkJCQkJKjpjbm9yZWEqICo6Y25vcmVhYmJyZXYqCjpjbm9yZWFbYmJyZXZdIFs8ZXhwcj5dIFs8YnVmZmVyPl0gW2xoc10gW3Joc10KCQkJc2FtZSBhcyAiOmFiIiwgYnV0IGZvciBDb21tYW5kLWxpbmUgbW9kZSBvbmx5IGFuZCBubwoJCQlyZW1hcHBpbmcgZm9yIHRoaXMge3Joc30ge25vdCBpbiBWaX0KCgkJCQkJCSo6aWEqICo6aWFiYnJldioKOmlhW2JicmV2XSBbPGV4cHI+XSBbPGJ1ZmZlcj5dIFtsaHNdIFtyaHNdCgkJCXNhbWUgYXMgIjphYiIsIGJ1dCBmb3IgSW5zZXJ0IG1vZGUgb25seS4gIHtub3QgaW4gVml9CgoJCQkJCQkqOml1bmEqICo6aXVuYWJicmV2Kgo6aXVuYVtiYnJldl0ge2xoc30Jc2FtZSBhcyAiOnVuYSIsIGJ1dCBmb3IgaW5zZXJ0IG1vZGUgb25seS4gIHtub3QgaW4KCQkJVml9CgoJCQkJCQkqOmlub3JlYSogKjppbm9yZWFiYnJldioKOmlub3JlYVtiYnJldl0gWzxleHByPl0gWzxidWZmZXI+XSBbbGhzXSBbcmhzXQoJCQlzYW1lIGFzICI6YWIiLCBidXQgZm9yIEluc2VydCBtb2RlIG9ubHkgYW5kIG5vCgkJCXJlbWFwcGluZyBmb3IgdGhpcyB7cmhzfSB7bm90IGluIFZpfQoKCQkJCQkJCSo6YWJjKiAqOmFiY2xlYXIqCjphYmNbbGVhcl0gWzxidWZmZXI+XQlSZW1vdmUgYWxsIGFiYnJldmlhdGlvbnMuICB7bm90IGluIFZpfQoKCQkJCQkJCSo6aWFiYyogKjppYWJjbGVhcioKOmlhYmNbbGVhcl0gWzxidWZmZXI+XQlSZW1vdmUgYWxsIGFiYnJldmlhdGlvbnMgZm9yIEluc2VydCBtb2RlLiAge25vdCBpbiBWaX0KCgkJCQkJCQkqOmNhYmMqICo6Y2FiY2xlYXIqCjpjYWJjW2xlYXJdIFs8YnVmZmVyPl0JUmVtb3ZlIGFsbCBhYmJyZXZpYXRpb25zIGZvciBDb21tYW5kLWxpbmUgbW9kZS4gIHtub3QKCQkJaW4gVml9CgoJCQkJCQkJKnVzaW5nX0NUUkwtVioKSXQgaXMgcG9zc2libGUgdG8gdXNlIHNwZWNpYWwgY2hhcmFjdGVycyBpbiB0aGUgcmhzIG9mIGFuIGFiYnJldmlhdGlvbi4KQ1RSTC1WIGhhcyB0byBiZSB1c2VkIHRvIGF2b2lkIHRoZSBzcGVjaWFsIG1lYW5pbmcgb2YgbW9zdCBub24gcHJpbnRhYmxlCmNoYXJhY3RlcnMuICBIb3cgbWFueSBDVFJMLVZzIG5lZWQgdG8gYmUgdHlwZWQgZGVwZW5kcyBvbiBob3cgeW91IGVudGVyIHRoZQphYmJyZXZpYXRpb24uICBUaGlzIGFsc28gYXBwbGllcyB0byBtYXBwaW5ncy4gIExldCdzIHVzZSBhbiBleGFtcGxlIGhlcmUuCgpTdXBwb3NlIHlvdSB3YW50IHRvIGFiYnJldmlhdGUgImVzYyIgdG8gZW50ZXIgYW4gPEVzYz4gY2hhcmFjdGVyLiAgV2hlbiB5b3UKdHlwZSB0aGUgIjphYiIgY29tbWFuZCBpbiBWaW0sIHlvdSBoYXZlIHRvIGVudGVyIHRoaXM6IChoZXJlIF5WIGlzIGEgQ1RSTC1WCmFuZCBeWyBpcyA8RXNjPikKCllvdSB0eXBlOiAgIGFiIGVzYyBeVl5WXlZeVl5WXlsKCglBbGwga2V5Ym9hcmQgaW5wdXQgaXMgc3ViamVjdGVkIHRvIF5WIHF1b3RlIGludGVycHJldGF0aW9uLCBzbwoJdGhlIGZpcnN0LCB0aGlyZCwgYW5kIGZpZnRoIF5WICBjaGFyYWN0ZXJzIHNpbXBseSBhbGxvdyB0aGUgc2Vjb25kLAoJYW5kIGZvdXJ0aCBeVnMsIGFuZCB0aGUgXlssIHRvIGJlIGVudGVyZWQgaW50byB0aGUgY29tbWFuZC1saW5lLgoKWW91IHNlZTogICAgYWIgZXNjIF5WXlZeWwoKCVRoZSBjb21tYW5kLWxpbmUgY29udGFpbnMgdHdvIGFjdHVhbCBeVnMgYmVmb3JlIHRoZSBeWy4gIFRoaXMgaXMKCWhvdyBpdCBzaG91bGQgYXBwZWFyIGluIHlvdXIgLmV4cmMgZmlsZSwgaWYgeW91IGNob29zZSB0byBnbyB0aGF0Cglyb3V0ZS4gIFRoZSBmaXJzdCBeViBpcyB0aGVyZSB0byBxdW90ZSB0aGUgc2Vjb25kIF5WOyB0aGUgOmFiCgljb21tYW5kIHVzZXMgXlYgYXMgaXRzIG93biBxdW90ZSBjaGFyYWN0ZXIsIHNvIHlvdSBjYW4gaW5jbHVkZSBxdW90ZWQKCXdoaXRlc3BhY2Ugb3IgdGhlIHwgY2hhcmFjdGVyIGluIHRoZSBhYmJyZXZpYXRpb24uICBUaGUgOmFiIGNvbW1hbmQKCWRvZXNuJ3QgZG8gYW55dGhpbmcgc3BlY2lhbCB3aXRoIHRoZSBeWyBjaGFyYWN0ZXIsIHNvIGl0IGRvZXNuJ3QgbmVlZAoJdG8gYmUgcXVvdGVkLiAgKEFsdGhvdWdoIHF1b3RpbmcgaXNuJ3QgaGFybWZ1bDsgdGhhdCdzIHdoeSB0eXBpbmcgNwoJW2J1dCBub3QgOCFdIF5WcyB3b3Jrcy4pCgpTdG9yZWQgYXM6ICBlc2MgICAgIF5WXlsKCglBZnRlciBwYXJzaW5nLCB0aGUgYWJicmV2aWF0aW9uJ3Mgc2hvcnQgZm9ybSAoImVzYyIpIGFuZCBsb25nIGZvcm0KCSh0aGUgdHdvIGNoYXJhY3RlcnMgIl5WXlsiKSBhcmUgc3RvcmVkIGluIHRoZSBhYmJyZXZpYXRpb24gdGFibGUuCglJZiB5b3UgZ2l2ZSB0aGUgOmFiIGNvbW1hbmQgd2l0aCBubyBhcmd1bWVudHMsIHRoaXMgaXMgaG93IHRoZQoJYWJicmV2aWF0aW9uIHdpbGwgYmUgZGlzcGxheWVkLgoKCUxhdGVyLCB3aGVuIHRoZSBhYmJyZXZpYXRpb24gaXMgZXhwYW5kZWQgYmVjYXVzZSB0aGUgdXNlciB0eXBlZCBpbgoJdGhlIHdvcmQgImVzYyIsIHRoZSBsb25nIGZvcm0gaXMgc3ViamVjdGVkIHRvIHRoZSBzYW1lIHR5cGUgb2YKCV5WIGludGVycHJldGF0aW9uIGFzIGtleWJvYXJkIGlucHV0LiAgU28gdGhlIF5WIHByb3RlY3RzIHRoZSBeWwoJY2hhcmFjdGVyIGZyb20gYmVpbmcgaW50ZXJwcmV0ZWQgYXMgdGhlICJleGl0IEluc2VydCBtb2RlIiBjaGFyYWN0ZXIuCglJbnN0ZWFkLCB0aGUgXlsgaXMgaW5zZXJ0ZWQgaW50byB0aGUgdGV4dC4KCkV4cGFuZHMgdG86IF5bCgpbZXhhbXBsZSBnaXZlbiBieSBTdGV2ZSBLaXJrZW5kYWxsXQoKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CjMuIExvY2FsIG1hcHBpbmdzIGFuZCBmdW5jdGlvbnMJCQkJKnNjcmlwdC1sb2NhbCoKCldoZW4gdXNpbmcgc2V2ZXJhbCBWaW0gc2NyaXB0IGZpbGVzLCB0aGVyZSBpcyB0aGUgZGFuZ2VyIHRoYXQgbWFwcGluZ3MgYW5kCmZ1bmN0aW9ucyB1c2VkIGluIG9uZSBzY3JpcHQgdXNlIHRoZSBzYW1lIG5hbWUgYXMgaW4gb3RoZXIgc2NyaXB0cy4gIFRvIGF2b2lkCnRoaXMsIHRoZXkgY2FuIGJlIG1hZGUgbG9jYWwgdG8gdGhlIHNjcmlwdC4KCgkJCQkJCSo8U0lEPiogKjxTTlI+KiAqRTgxKgpUaGUgc3RyaW5nICI8U0lEPiIgY2FuIGJlIHVzZWQgaW4gYSBtYXBwaW5nIG9yIG1lbnUuICBUaGlzIHJlcXVpcmVzIHRoYXQgdGhlCic8JyBmbGFnIGlzIG5vdCBwcmVzZW50IGluICdjcG9wdGlvbnMnLgogICBXaGVuIGV4ZWN1dGluZyB0aGUgbWFwIGNvbW1hbmQsIFZpbSB3aWxsIHJlcGxhY2UgIjxTSUQ+IiB3aXRoIHRoZSBzcGVjaWFsCmtleSBjb2RlIDxTTlI+LCBmb2xsb3dlZCBieSBhIG51bWJlciB0aGF0J3MgdW5pcXVlIGZvciB0aGUgc2NyaXB0LCBhbmQgYW4KdW5kZXJzY29yZS4gIEV4YW1wbGU6ID4KCTptYXAgPFNJRD5BZGQKY291bGQgZGVmaW5lIGEgbWFwcGluZyAiPFNOUj4yM19BZGQiLgoKV2hlbiBkZWZpbmluZyBhIGZ1bmN0aW9uIGluIGEgc2NyaXB0LCAiczoiIGNhbiBiZSBwcmVwZW5kZWQgdG8gdGhlIG5hbWUgdG8KbWFrZSBpdCBsb2NhbCB0byB0aGUgc2NyaXB0LiAgQnV0IHdoZW4gYSBtYXBwaW5nIGlzIGV4ZWN1dGVkIGZyb20gb3V0c2lkZSBvZgp0aGUgc2NyaXB0LCBpdCBkb2Vzbid0IGtub3cgaW4gd2hpY2ggc2NyaXB0IHRoZSBmdW5jdGlvbiB3YXMgZGVmaW5lZC4gIFRvCmF2b2lkIHRoaXMgcHJvYmxlbSwgdXNlICI8U0lEPiIgaW5zdGVhZCBvZiAiczoiLiAgVGhlIHNhbWUgdHJhbnNsYXRpb24gaXMgZG9uZQphcyBmb3IgbWFwcGluZ3MuICBUaGlzIG1ha2VzIGl0IHBvc3NpYmxlIHRvIGRlZmluZSBhIGNhbGwgdG8gdGhlIGZ1bmN0aW9uIGluCmEgbWFwcGluZy4KCldoZW4gYSBsb2NhbCBmdW5jdGlvbiBpcyBleGVjdXRlZCwgaXQgcnVucyBpbiB0aGUgY29udGV4dCBvZiB0aGUgc2NyaXB0IGl0IHdhcwpkZWZpbmVkIGluLiAgVGhpcyBtZWFucyB0aGF0IG5ldyBmdW5jdGlvbnMgYW5kIG1hcHBpbmdzIGl0IGRlZmluZXMgY2FuIGFsc28KdXNlICJzOiIgb3IgIjxTSUQ+IiBhbmQgaXQgd2lsbCB1c2UgdGhlIHNhbWUgdW5pcXVlIG51bWJlciBhcyB3aGVuIHRoZQpmdW5jdGlvbiBpdHNlbGYgd2FzIGRlZmluZWQuICBBbHNvLCB0aGUgInM6dmFyIiBsb2NhbCBzY3JpcHQgdmFyaWFibGVzIGNhbiBiZQp1c2VkLgoKV2hlbiBleGVjdXRpbmcgYW4gYXV0b2NvbW1hbmQgb3IgYSB1c2VyIGNvbW1hbmQsIGl0IHdpbGwgcnVuIGluIHRoZSBjb250ZXh0IG9mCnRoZSBzY3JpcHQgaXQgd2FzIGRlZmluZWQgaW4uICBUaGlzIG1ha2VzIGl0IHBvc3NpYmxlIHRoYXQgdGhlIGNvbW1hbmQgY2FsbHMgYQpsb2NhbCBmdW5jdGlvbiBvciB1c2VzIGEgbG9jYWwgbWFwcGluZy4KCk90aGVyd2lzZSwgdXNpbmcgIjxTSUQ+IiBvdXRzaWRlIG9mIGEgc2NyaXB0IGNvbnRleHQgaXMgYW4gZXJyb3IuCgpJZiB5b3UgbmVlZCB0byBnZXQgdGhlIHNjcmlwdCBudW1iZXIgdG8gdXNlIGluIGEgY29tcGxpY2F0ZWQgc2NyaXB0LCB5b3UgY2FuCnVzZSB0aGlzIGZ1bmN0aW9uOiA+CglmdW5jdGlvbiBzOlNJRCgpCgkgIHJldHVybiBtYXRjaHN0cihleHBhbmQoJzxzZmlsZT4nKSwgJzxTTlI+XHpzXGRcK1x6ZV9TSUQkJykKCWVuZGZ1bgoKVGhlICI8U05SPiIgd2lsbCBiZSBzaG93biB3aGVuIGxpc3RpbmcgZnVuY3Rpb25zIGFuZCBtYXBwaW5ncy4gIFRoaXMgaXMgdXNlZnVsCnRvIGZpbmQgb3V0IHdoYXQgdGhleSBhcmUgZGVmaW5lZCB0by4KClRoZSB8OnNjcmlwdG5hbWVzfCBjb21tYW5kIGNhbiBiZSB1c2VkIHRvIHNlZSB3aGljaCBzY3JpcHRzIGhhdmUgYmVlbiBzb3VyY2VkCmFuZCB3aGF0IHRoZWlyIDxTTlI+IG51bWJlciBpcy4KClRoaXMgaXMgYWxsIHtub3QgaW4gVml9IGFuZCB7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZXZhbHwKZmVhdHVyZX0uCgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KNC4gVXNlci1kZWZpbmVkIGNvbW1hbmRzCQkJCSp1c2VyLWNvbW1hbmRzKgoKSXQgaXMgcG9zc2libGUgdG8gZGVmaW5lIHlvdXIgb3duIEV4IGNvbW1hbmRzLiAgQSB1c2VyLWRlZmluZWQgY29tbWFuZCBjYW4gYWN0Cmp1c3QgbGlrZSBhIGJ1aWx0LWluIGNvbW1hbmQgKGl0IGNhbiBoYXZlIGEgcmFuZ2Ugb3IgYXJndW1lbnRzLCBhcmd1bWVudHMgY2FuCmJlIGNvbXBsZXRlZCBhcyBmaWxlbmFtZXMgb3IgYnVmZmVyIG5hbWVzLCBldGMpLCBleGNlcHQgdGhhdCB3aGVuIHRoZSBjb21tYW5kCmlzIGV4ZWN1dGVkLCBpdCBpcyB0cmFuc2Zvcm1lZCBpbnRvIGEgbm9ybWFsIEV4IGNvbW1hbmQgYW5kIHRoZW4gZXhlY3V0ZWQuCgpGb3Igc3RhcnRlcnM6IFNlZSBzZWN0aW9uIHw0MC4yfCBpbiB0aGUgdXNlciBtYW51YWwuCgoJCQkJCSpFMTgzKiAqRTg0MSogKnVzZXItY21kLWFtYmlndW91cyoKQWxsIHVzZXIgZGVmaW5lZCBjb21tYW5kcyBtdXN0IHN0YXJ0IHdpdGggYW4gdXBwZXJjYXNlIGxldHRlciwgdG8gYXZvaWQKY29uZnVzaW9uIHdpdGggYnVpbHRpbiBjb21tYW5kcy4gIEV4Y2VwdGlvbnMgYXJlIHRoZXNlIGJ1aWx0aW4gY29tbWFuZHM6Cgk6TmV4dAoJOlgKVGhleSBjYW5ub3QgYmUgdXNlZCBmb3IgYSB1c2VyIGRlZmluZWQgY29tbWFuZC4gICI6UHJpbnQiIGlzIGFsc28gYW4gZXhpc3RpbmcKY29tbWFuZCwgYnV0IGl0IGlzIGRlcHJlY2F0ZWQgYW5kIGNhbiBiZSBvdmVycnVsZWQuCgpUaGUgb3RoZXIgY2hhcmFjdGVycyBvZiB0aGUgdXNlciBjb21tYW5kIGNhbiBiZSB1cHBlcmNhc2UgbGV0dGVycywgbG93ZXJjYXNlCmxldHRlcnMgb3IgZGlnaXRzLiAgV2hlbiB1c2luZyBkaWdpdHMsIG5vdGUgdGhhdCBvdGhlciBjb21tYW5kcyB0aGF0IHRha2UgYQpudW1lcmljIGFyZ3VtZW50IG1heSBiZWNvbWUgYW1iaWd1b3VzLiAgRm9yIGV4YW1wbGUsIHRoZSBjb21tYW5kICI6Q2MyIiBjb3VsZApiZSB0aGUgdXNlciBjb21tYW5kICI6Q2MyIiB3aXRob3V0IGFuIGFyZ3VtZW50LCBvciB0aGUgY29tbWFuZCAiOkNjIiB3aXRoCmFyZ3VtZW50ICIyIi4gIEl0IGlzIGFkdmlzZWQgdG8gcHV0IGEgc3BhY2UgYmV0d2VlbiB0aGUgY29tbWFuZCBuYW1lIGFuZCB0aGUKYXJndW1lbnQgdG8gYXZvaWQgdGhlc2UgcHJvYmxlbXMuCgpXaGVuIHVzaW5nIGEgdXNlci1kZWZpbmVkIGNvbW1hbmQsIHRoZSBjb21tYW5kIGNhbiBiZSBhYmJyZXZpYXRlZC4gIEhvd2V2ZXIsIGlmCmFuIGFiYnJldmlhdGlvbiBpcyBub3QgdW5pcXVlLCBhbiBlcnJvciB3aWxsIGJlIGlzc3VlZC4gIEZ1cnRoZXJtb3JlLCBhCmJ1aWx0LWluIGNvbW1hbmQgd2lsbCBhbHdheXMgdGFrZSBwcmVjZWRlbmNlLgoKRXhhbXBsZTogPgoJOmNvbW1hbmQgUmVuYW1lIC4uLgoJOmNvbW1hbmQgUmVudW1iZXIgLi4uCgk6UmVuYQkJCQkiIE1lYW5zICJSZW5hbWUiCgk6UmVudQkJCQkiIE1lYW5zICJSZW51bWJlciIKCTpSZW4JCQkJIiBFcnJvciAtIGFtYmlndW91cwoJOmNvbW1hbmQgUGFzdGUgLi4uCgk6UAkJCQkiIFRoZSBidWlsdC1pbiA6UHJpbnQKCkl0IGlzIHJlY29tbWVuZGVkIHRoYXQgZnVsbCBuYW1lcyBmb3IgdXNlci1kZWZpbmVkIGNvbW1hbmRzIGFyZSB1c2VkIGluCnNjcmlwdHMuCgo6Y29tW21hbmRdCQkJCQkJKjpjb20qICo6Y29tbWFuZCoKCQkJTGlzdCBhbGwgdXNlci1kZWZpbmVkIGNvbW1hbmRzLiAgV2hlbiBsaXN0aW5nIGNvbW1hbmRzLAoJCQl0aGUgY2hhcmFjdGVycyBpbiB0aGUgZmlyc3QgdHdvIGNvbHVtbnMgYXJlCgkJCSAgICAhCUNvbW1hbmQgaGFzIHRoZSAtYmFuZyBhdHRyaWJ1dGUKCQkJICAgICIJQ29tbWFuZCBoYXMgdGhlIC1yZWdpc3RlciBhdHRyaWJ1dGUKCQkJICAgIGIJQ29tbWFuZCBpcyBsb2NhbCB0byBjdXJyZW50IGJ1ZmZlcgoJCQkoc2VlIGJlbG93IGZvciBkZXRhaWxzIG9uIGF0dHJpYnV0ZXMpCgo6Y29tW21hbmRdIHtjbWR9CUxpc3QgdGhlIHVzZXItZGVmaW5lZCBjb21tYW5kcyB0aGF0IHN0YXJ0IHdpdGgge2NtZH0KCgkJCQkJCQkqOmNvbW1hbmQtdmVyYm9zZSoKV2hlbiAndmVyYm9zZScgaXMgbm9uLXplcm8sIGxpc3RpbmcgYSBjb21tYW5kIHdpbGwgYWxzbyBkaXNwbGF5IHdoZXJlIGl0IHdhcwpsYXN0IGRlZmluZWQuIEV4YW1wbGU6ID4KCiAgICA6dmVyYm9zZSBjb21tYW5kIFRPaHRtbAo8CU5hbWUJICAgIEFyZ3MgUmFuZ2UgQ29tcGxldGUgIERlZmluaXRpb24gfgoJVE9odG1sCSAgICAwCSAlCQkgOmNhbGwgQ29udmVydDJIVE1MKDxsaW5lMT4sIDxsaW5lMj4pIH4KCSAgICBMYXN0IHNldCBmcm9tIC91c3Ivc2hhcmUvdmltL3ZpbS03LjAvcGx1Z2luL3RvaHRtbC52aW0gfgoKU2VlIHw6dmVyYm9zZS1jbWR8IGZvciBtb3JlIGluZm9ybWF0aW9uLgoKCQkJCQkJCSpFMTc0KiAqRTE4MioKOmNvbVttYW5kXVshXSBbe2F0dHJ9Li4uXSB7Y21kfSB7cmVwfQoJCQlEZWZpbmUgYSB1c2VyIGNvbW1hbmQuICBUaGUgbmFtZSBvZiB0aGUgY29tbWFuZCBpcwoJCQl7Y21kfSBhbmQgaXRzIHJlcGxhY2VtZW50IHRleHQgaXMge3JlcH0uICBUaGUgY29tbWFuZCdzCgkJCWF0dHJpYnV0ZXMgKHNlZSBiZWxvdykgYXJlIHthdHRyfS4gIElmIHRoZSBjb21tYW5kCgkJCWFscmVhZHkgZXhpc3RzLCBhbiBlcnJvciBpcyByZXBvcnRlZCwgdW5sZXNzIGEgISBpcwoJCQlzcGVjaWZpZWQsIGluIHdoaWNoIGNhc2UgdGhlIGNvbW1hbmQgaXMgcmVkZWZpbmVkLgoKOmRlbGNbb21tYW5kXSB7Y21kfQkJCQkqOmRlbGMqICo6ZGVsY29tbWFuZCogKkUxODQqCgkJCURlbGV0ZSB0aGUgdXNlci1kZWZpbmVkIGNvbW1hbmQge2NtZH0uCgo6Y29tY1tsZWFyXQkJCQkJCSo6Y29tYyogKjpjb21jbGVhcioKCQkJRGVsZXRlIGFsbCB1c2VyLWRlZmluZWQgY29tbWFuZHMuCgpDb21tYW5kIGF0dHJpYnV0ZXMKClVzZXItZGVmaW5lZCBjb21tYW5kcyBhcmUgdHJlYXRlZCBieSBWaW0ganVzdCBsaWtlIGFueSBvdGhlciBFeCBjb21tYW5kcy4gIFRoZXkKY2FuIGhhdmUgYXJndW1lbnRzLCBvciBoYXZlIGEgcmFuZ2Ugc3BlY2lmaWVkLiAgQXJndW1lbnRzIGFyZSBzdWJqZWN0IHRvCmNvbXBsZXRpb24gYXMgZmlsZW5hbWVzLCBidWZmZXJzLCBldGMuICBFeGFjdGx5IGhvdyB0aGlzIHdvcmtzIGRlcGVuZHMgdXBvbiB0aGUKY29tbWFuZCdzIGF0dHJpYnV0ZXMsIHdoaWNoIGFyZSBzcGVjaWZpZWQgd2hlbiB0aGUgY29tbWFuZCBpcyBkZWZpbmVkLgoKVGhlcmUgYXJlIGEgbnVtYmVyIG9mIGF0dHJpYnV0ZXMsIHNwbGl0IGludG8gZm91ciBjYXRlZ29yaWVzOiBhcmd1bWVudApoYW5kbGluZywgY29tcGxldGlvbiBiZWhhdmlvciwgcmFuZ2UgaGFuZGxpbmcsIGFuZCBzcGVjaWFsIGNhc2VzLiAgVGhlCmF0dHJpYnV0ZXMgYXJlIGRlc2NyaWJlZCBiZWxvdywgYnkgY2F0ZWdvcnkuCgpBcmd1bWVudCBoYW5kbGluZwkJCQkqRTE3NSogKkUxNzYqICo6Y29tbWFuZC1uYXJncyoKCkJ5IGRlZmF1bHQsIGEgdXNlciBkZWZpbmVkIGNvbW1hbmQgd2lsbCB0YWtlIG5vIGFyZ3VtZW50cyAoYW5kIGFuIGVycm9yIGlzCnJlcG9ydGVkIGlmIGFueSBhcmUgc3VwcGxpZWQpLiAgSG93ZXZlciwgaXQgaXMgcG9zc2libGUgdG8gc3BlY2lmeSB0aGF0IHRoZQpjb21tYW5kIGNhbiB0YWtlIGFyZ3VtZW50cywgdXNpbmcgdGhlIC1uYXJncyBhdHRyaWJ1dGUuICBWYWxpZCBjYXNlcyBhcmU6CgoJLW5hcmdzPTAgICAgTm8gYXJndW1lbnRzIGFyZSBhbGxvd2VkICh0aGUgZGVmYXVsdCkKCS1uYXJncz0xICAgIEV4YWN0bHkgb25lIGFyZ3VtZW50IGlzIHJlcXVpcmVkLCBpdCBpbmNsdWRlcyBzcGFjZXMgCgktbmFyZ3M9KiAgICBBbnkgbnVtYmVyIG9mIGFyZ3VtZW50cyBhcmUgYWxsb3dlZCAoMCwgMSwgb3IgbWFueSksCgkJICAgIHNlcGFyYXRlZCBieSB3aGl0ZSBzcGFjZQoJLW5hcmdzPT8gICAgMCBvciAxIGFyZ3VtZW50cyBhcmUgYWxsb3dlZAoJLW5hcmdzPSsgICAgQXJndW1lbnRzIG11c3QgYmUgc3VwcGxpZWQsIGJ1dCBhbnkgbnVtYmVyIGFyZSBhbGxvd2VkCgpBcmd1bWVudHMgYXJlIGNvbnNpZGVyZWQgdG8gYmUgc2VwYXJhdGVkIGJ5ICh1bmVzY2FwZWQpIHNwYWNlcyBvciB0YWJzIGluIHRoaXMKY29udGV4dCwgZXhjZXB0IHdoZW4gdGhlcmUgaXMgb25lIGFyZ3VtZW50LCB0aGVuIHRoZSB3aGl0ZSBzcGFjZSBpcyBwYXJ0IG9mCnRoZSBhcmd1bWVudC4KCk5vdGUgdGhhdCBhcmd1bWVudHMgYXJlIHVzZWQgYXMgdGV4dCwgbm90IGFzIGV4cHJlc3Npb25zLiAgU3BlY2lmaWNhbGx5LAoiczp2YXIiIHdpbGwgdXNlIHRoZSBzY3JpcHQtbG9jYWwgdmFyaWFibGUgaW4gdGhlIHNjcmlwdCB3aGVyZSB0aGUgY29tbWFuZCB3YXMKZGVmaW5lZCwgbm90IHdoZXJlIGl0IGlzIGludm9rZWQhICBFeGFtcGxlOgogICAgc2NyaXB0MS52aW06ID4KCTpsZXQgczplcnJvciA9ICJOb25lIgoJOmNvbW1hbmQgLW5hcmdzPTEgRXJyb3IgZWNob2VyciA8YXJncz4KPCAgIHNjcmlwdDIudmltOiA+Cgk6c291cmNlIHNjcmlwdDEudmltCgk6bGV0IHM6ZXJyb3IgPSAiV3JvbmchIgoJOkVycm9yIHM6ZXJyb3IKRXhlY3V0aW5nIHNjcmlwdDIudmltIHdpbGwgcmVzdWx0IGluICJOb25lIiBiZWluZyBlY2hvZWQuICBOb3Qgd2hhdCB5b3UKaW50ZW5kZWQhICBDYWxsaW5nIGEgZnVuY3Rpb24gbWF5IGJlIGFuIGFsdGVybmF0aXZlLgoKQ29tcGxldGlvbiBiZWhhdmlvcgkJCQkqOmNvbW1hbmQtY29tcGxldGlvbiogKkUxNzkqCgkJCQkJKkUxODAqICpFMTgxKiAqOmNvbW1hbmQtY29tcGxldGUqCkJ5IGRlZmF1bHQsIHRoZSBhcmd1bWVudHMgb2YgdXNlciBkZWZpbmVkIGNvbW1hbmRzIGRvIG5vdCB1bmRlcmdvIGNvbXBsZXRpb24uCkhvd2V2ZXIsIGJ5IHNwZWNpZnlpbmcgb25lIG9yIHRoZSBvdGhlciBvZiB0aGUgZm9sbG93aW5nIGF0dHJpYnV0ZXMsIGFyZ3VtZW50CmNvbXBsZXRpb24gY2FuIGJlIGVuYWJsZWQ6CgoJLWNvbXBsZXRlPWF1Z3JvdXAJYXV0b2NtZCBncm91cHMKCS1jb21wbGV0ZT1idWZmZXIJYnVmZmVyIG5hbWVzCgktY29tcGxldGU9YmVoYXZlCTpiZWhhdmUgc3Vib3B0aW9ucwoJLWNvbXBsZXRlPWNvbG9yCQljb2xvciBzY2hlbWVzCgktY29tcGxldGU9Y29tbWFuZAlFeCBjb21tYW5kIChhbmQgYXJndW1lbnRzKQoJLWNvbXBsZXRlPWNvbXBpbGVyCWNvbXBpbGVycwoJLWNvbXBsZXRlPWNzY29wZQl8OmNzY29wZXwgc3Vib3B0aW9ucwoJLWNvbXBsZXRlPWRpcgkJZGlyZWN0b3J5IG5hbWVzCgktY29tcGxldGU9ZW52aXJvbm1lbnQJZW52aXJvbm1lbnQgdmFyaWFibGUgbmFtZXMKCS1jb21wbGV0ZT1ldmVudAkJYXV0b2NvbW1hbmQgZXZlbnRzCgktY29tcGxldGU9ZXhwcmVzc2lvbglWaW0gZXhwcmVzc2lvbgoJLWNvbXBsZXRlPWZpbGUJCWZpbGUgYW5kIGRpcmVjdG9yeSBuYW1lcwoJLWNvbXBsZXRlPWZpbGVfaW5fcGF0aAlmaWxlIGFuZCBkaXJlY3RvcnkgbmFtZXMgaW4gfCdwYXRoJ3wKCS1jb21wbGV0ZT1maWxldHlwZQlmaWxldHlwZSBuYW1lcyB8J2ZpbGV0eXBlJ3wKCS1jb21wbGV0ZT1mdW5jdGlvbglmdW5jdGlvbiBuYW1lCgktY29tcGxldGU9aGVscAkJaGVscCBzdWJqZWN0cwoJLWNvbXBsZXRlPWhpZ2hsaWdodAloaWdobGlnaHQgZ3JvdXBzCgktY29tcGxldGU9aGlzdG9yeQk6aGlzdG9yeSBzdWJvcHRpb25zCgktY29tcGxldGU9bG9jYWxlCWxvY2FsZSBuYW1lcyAoYXMgb3V0cHV0IG9mIGxvY2FsZSAtYSkKCS1jb21wbGV0ZT1tYXBwaW5nCW1hcHBpbmcgbmFtZQoJLWNvbXBsZXRlPW1lbnUJCW1lbnVzCgktY29tcGxldGU9b3B0aW9uCW9wdGlvbnMKCS1jb21wbGV0ZT1zaGVsbGNtZAlTaGVsbCBjb21tYW5kCgktY29tcGxldGU9c2lnbgkJfDpzaWdufCBzdWJvcHRpb25zCgktY29tcGxldGU9c3ludGF4CXN5bnRheCBmaWxlIG5hbWVzIHwnc3ludGF4J3wKCS1jb21wbGV0ZT1zeW50aW1lCXw6c3ludGltZXwgc3Vib3B0aW9ucwoJLWNvbXBsZXRlPXRhZwkJdGFncwoJLWNvbXBsZXRlPXRhZ19saXN0ZmlsZXMJdGFncywgZmlsZSBuYW1lcyBhcmUgc2hvd24gd2hlbiBDVFJMLUQgaXMgaGl0CgktY29tcGxldGU9dXNlcgkJdXNlciBuYW1lcwoJLWNvbXBsZXRlPXZhcgkJdXNlciB2YXJpYWJsZXMKCS1jb21wbGV0ZT1jdXN0b20se2Z1bmN9IGN1c3RvbSBjb21wbGV0aW9uLCBkZWZpbmVkIHZpYSB7ZnVuY30KCS1jb21wbGV0ZT1jdXN0b21saXN0LHtmdW5jfSBjdXN0b20gY29tcGxldGlvbiwgZGVmaW5lZCB2aWEge2Z1bmN9CgoKQ3VzdG9tIGNvbXBsZXRpb24JCQkqOmNvbW1hbmQtY29tcGxldGlvbi1jdXN0b20qCgkJCQkJKjpjb21tYW5kLWNvbXBsZXRpb24tY3VzdG9tbGlzdCoKCQkJCQkqRTQ2NyogKkU0NjgqCkl0IGlzIHBvc3NpYmxlIHRvIGRlZmluZSBjdXN0b21pemVkIGNvbXBsZXRpb24gc2NoZW1lcyB2aWEgdGhlICJjdXN0b20se2Z1bmN9IgpvciB0aGUgImN1c3RvbWxpc3Qse2Z1bmN9IiBjb21wbGV0aW9uIGFyZ3VtZW50LiAgVGhlIHtmdW5jfSBwYXJ0IHNob3VsZCBiZSBhCmZ1bmN0aW9uIHdpdGggdGhlIGZvbGxvd2luZyBzaWduYXR1cmU6ID4KCgk6ZnVuY3Rpb24ge2Z1bmN9KEFyZ0xlYWQsIENtZExpbmUsIEN1cnNvclBvcykKClRoZSBmdW5jdGlvbiBuZWVkIG5vdCB1c2UgYWxsIHRoZXNlIGFyZ3VtZW50cy4gVGhlIGZ1bmN0aW9uIHNob3VsZCBwcm92aWRlIHRoZQpjb21wbGV0aW9uIGNhbmRpZGF0ZXMgYXMgdGhlIHJldHVybiB2YWx1ZS4KCkZvciB0aGUgImN1c3RvbSIgYXJndW1lbnQsIHRoZSBmdW5jdGlvbiBzaG91bGQgcmV0dXJuIHRoZSBjb21wbGV0aW9uCmNhbmRpZGF0ZXMgb25lIHBlciBsaW5lIGluIGEgbmV3bGluZSBzZXBhcmF0ZWQgc3RyaW5nLgoKRm9yIHRoZSAiY3VzdG9tbGlzdCIgYXJndW1lbnQsIHRoZSBmdW5jdGlvbiBzaG91bGQgcmV0dXJuIHRoZSBjb21wbGV0aW9uCmNhbmRpZGF0ZXMgYXMgYSBWaW0gTGlzdC4gIE5vbi1zdHJpbmcgaXRlbXMgaW4gdGhlIGxpc3QgYXJlIGlnbm9yZWQuCgpUaGUgZnVuY3Rpb24gYXJndW1lbnRzIGFyZToKCUFyZ0xlYWQJCXRoZSBsZWFkaW5nIHBvcnRpb24gb2YgdGhlIGFyZ3VtZW50IGN1cnJlbnRseSBiZWluZwoJCQljb21wbGV0ZWQgb24KCUNtZExpbmUJCXRoZSBlbnRpcmUgY29tbWFuZCBsaW5lCglDdXJzb3JQb3MJdGhlIGN1cnNvciBwb3NpdGlvbiBpbiBpdCAoYnl0ZSBpbmRleCkKVGhlIGZ1bmN0aW9uIG1heSB1c2UgdGhlc2UgZm9yIGRldGVybWluaW5nIGNvbnRleHQuICBGb3IgdGhlICJjdXN0b20iCmFyZ3VtZW50LCBpdCBpcyBub3QgbmVjZXNzYXJ5IHRvIGZpbHRlciBjYW5kaWRhdGVzIGFnYWluc3QgdGhlIChpbXBsaWNpdApwYXR0ZXJuIGluKSBBcmdMZWFkLiAgVmltIHdpbGwgZmlsdGVyIHRoZSBjYW5kaWRhdGVzIHdpdGggaXRzIHJlZ2V4cCBlbmdpbmUKYWZ0ZXIgZnVuY3Rpb24gcmV0dXJuLCBhbmQgdGhpcyBpcyBwcm9iYWJseSBtb3JlIGVmZmljaWVudCBpbiBtb3N0IGNhc2VzLiBGb3IKdGhlICJjdXN0b21saXN0IiBhcmd1bWVudCwgVmltIHdpbGwgbm90IGZpbHRlciB0aGUgcmV0dXJuZWQgY29tcGxldGlvbgpjYW5kaWRhdGVzIGFuZCB0aGUgdXNlciBzdXBwbGllZCBmdW5jdGlvbiBzaG91bGQgZmlsdGVyIHRoZSBjYW5kaWRhdGVzLgoKVGhlIGZvbGxvd2luZyBleGFtcGxlIGxpc3RzIHVzZXIgbmFtZXMgdG8gYSBGaW5nZXIgY29tbWFuZCA+CiAgICA6Y29tIC1jb21wbGV0ZT1jdXN0b20sTGlzdFVzZXJzIC1uYXJncz0xIEZpbmdlciAhZmluZ2VyIDxhcmdzPgogICAgOmZ1biBMaXN0VXNlcnMoQSxMLFApCiAgICA6ICAgIHJldHVybiBzeXN0ZW0oImN1dCAtZDogLWYxIC9ldGMvcGFzc3dkIikKICAgIDplbmRmdW4KClRoZSBmb2xsb3dpbmcgZXhhbXBsZSBjb21wbGV0ZXMgZmlsZW5hbWVzIGZyb20gdGhlIGRpcmVjdG9yaWVzIHNwZWNpZmllZCBpbgp0aGUgJ3BhdGgnIG9wdGlvbjogPgogICAgOmNvbSAtbmFyZ3M9MSAtYmFuZyAtY29tcGxldGU9Y3VzdG9tbGlzdCxFZGl0RmlsZUNvbXBsZXRlCgkJCVwgRWRpdEZpbGUgZWRpdDxiYW5nPiA8YXJncz4KICAgIDpmdW4gRWRpdEZpbGVDb21wbGV0ZShBLEwsUCkKICAgIDogICAgcmV0dXJuIHNwbGl0KGdsb2JwYXRoKCZwYXRoLCBhOkEpLCAiXG4iKQogICAgOmVuZGZ1bgo8ClRoaXMgZXhhbXBsZSBkb2VzIG5vdCB3b3JrIGZvciBmaWxlIG5hbWVzIHdpdGggc3BhY2VzIQoKClJhbmdlIGhhbmRsaW5nCQkJCSpFMTc3KiAqRTE3OCogKjpjb21tYW5kLXJhbmdlKgoJCQkJCQkJKjpjb21tYW5kLWNvdW50KgpCeSBkZWZhdWx0LCB1c2VyLWRlZmluZWQgY29tbWFuZHMgZG8gbm90IGFjY2VwdCBhIGxpbmUgbnVtYmVyIHJhbmdlLiAgSG93ZXZlciwKaXQgaXMgcG9zc2libGUgdG8gc3BlY2lmeSB0aGF0IHRoZSBjb21tYW5kIGRvZXMgdGFrZSBhIHJhbmdlICh0aGUgLXJhbmdlCmF0dHJpYnV0ZSksIG9yIHRoYXQgaXQgdGFrZXMgYW4gYXJiaXRyYXJ5IGNvdW50IHZhbHVlLCBlaXRoZXIgaW4gdGhlIGxpbmUKbnVtYmVyIHBvc2l0aW9uICgtcmFuZ2U9TiwgbGlrZSB0aGUgfDpzcGxpdHwgY29tbWFuZCkgb3IgYXMgYSAiY291bnQiCmFyZ3VtZW50ICgtY291bnQ9TiwgbGlrZSB0aGUgfDpOZXh0fCBjb21tYW5kKS4gIFRoZSBjb3VudCB3aWxsIHRoZW4gYmUKYXZhaWxhYmxlIGluIHRoZSBhcmd1bWVudCB3aXRoIHw8Y291bnQ+fC4KClBvc3NpYmxlIGF0dHJpYnV0ZXMgYXJlOgoKCS1yYW5nZQkgICAgUmFuZ2UgYWxsb3dlZCwgZGVmYXVsdCBpcyBjdXJyZW50IGxpbmUKCS1yYW5nZT0lICAgIFJhbmdlIGFsbG93ZWQsIGRlZmF1bHQgaXMgd2hvbGUgZmlsZSAoMSwkKQoJLXJhbmdlPU4gICAgQSBjb3VudCAoZGVmYXVsdCBOKSB3aGljaCBpcyBzcGVjaWZpZWQgaW4gdGhlIGxpbmUKCQkgICAgbnVtYmVyIHBvc2l0aW9uIChsaWtlIHw6c3BsaXR8KTsgYWxsb3dzIGZvciB6ZXJvIGxpbmUKCQkgICAgbnVtYmVyLgoJLWNvdW50PU4gICAgQSBjb3VudCAoZGVmYXVsdCBOKSB3aGljaCBpcyBzcGVjaWZpZWQgZWl0aGVyIGluIHRoZSBsaW5lCgkJICAgIG51bWJlciBwb3NpdGlvbiwgb3IgYXMgYW4gaW5pdGlhbCBhcmd1bWVudCAobGlrZSB8Ok5leHR8KS4KCQkgICAgU3BlY2lmeWluZyAtY291bnQgKHdpdGhvdXQgYSBkZWZhdWx0KSBhY3RzIGxpa2UgLWNvdW50PTAKCk5vdGUgdGhhdCAtcmFuZ2U9TiBhbmQgLWNvdW50PU4gYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSAtIG9ubHkgb25lIHNob3VsZCBiZQpzcGVjaWZpZWQuCgpTcGVjaWFsIGNhc2VzCQkJCSo6Y29tbWFuZC1iYW5nKiAqOmNvbW1hbmQtYmFyKgoJCQkJCSo6Y29tbWFuZC1yZWdpc3RlciogKjpjb21tYW5kLWJ1ZmZlcioKVGhlcmUgYXJlIHNvbWUgc3BlY2lhbCBjYXNlcyBhcyB3ZWxsOgoKCS1iYW5nCSAgICBUaGUgY29tbWFuZCBjYW4gdGFrZSBhICEgbW9kaWZpZXIgKGxpa2UgOnEgb3IgOncpCgktYmFyCSAgICBUaGUgY29tbWFuZCBjYW4gYmUgZm9sbG93ZWQgYnkgYSAifCIgYW5kIGFub3RoZXIgY29tbWFuZC4KCQkgICAgQSAifCIgaW5zaWRlIHRoZSBjb21tYW5kIGFyZ3VtZW50IGlzIG5vdCBhbGxvd2VkIHRoZW4uCgkJICAgIEFsc28gY2hlY2tzIGZvciBhICIgdG8gc3RhcnQgYSBjb21tZW50LgoJLXJlZ2lzdGVyICAgVGhlIGZpcnN0IGFyZ3VtZW50IHRvIHRoZSBjb21tYW5kIGNhbiBiZSBhbiBvcHRpb25hbAoJCSAgICByZWdpc3RlciBuYW1lIChsaWtlIDpkZWwsIDpwdXQsIDp5YW5rKS4KCS1idWZmZXIJICAgIFRoZSBjb21tYW5kIHdpbGwgb25seSBiZSBhdmFpbGFibGUgaW4gdGhlIGN1cnJlbnQgYnVmZmVyLgoKSW4gdGhlIGNhc2VzIG9mIHRoZSAtY291bnQgYW5kIC1yZWdpc3RlciBhdHRyaWJ1dGVzLCBpZiB0aGUgb3B0aW9uYWwgYXJndW1lbnQKaXMgc3VwcGxpZWQsIGl0IGlzIHJlbW92ZWQgZnJvbSB0aGUgYXJndW1lbnQgbGlzdCBhbmQgaXMgYXZhaWxhYmxlIHRvIHRoZQpyZXBsYWNlbWVudCB0ZXh0IHNlcGFyYXRlbHkuCgpSZXBsYWNlbWVudCB0ZXh0CgpUaGUgcmVwbGFjZW1lbnQgdGV4dCBmb3IgYSB1c2VyIGRlZmluZWQgY29tbWFuZCBpcyBzY2FubmVkIGZvciBzcGVjaWFsIGVzY2FwZQpzZXF1ZW5jZXMsIHVzaW5nIDwuLi4+IG5vdGF0aW9uLiAgRXNjYXBlIHNlcXVlbmNlcyBhcmUgcmVwbGFjZWQgd2l0aCB2YWx1ZXMKZnJvbSB0aGUgZW50ZXJlZCBjb21tYW5kIGxpbmUsIGFuZCBhbGwgb3RoZXIgdGV4dCBpcyBjb3BpZWQgdW5jaGFuZ2VkLiAgVGhlCnJlc3VsdGluZyBzdHJpbmcgaXMgZXhlY3V0ZWQgYXMgYW4gRXggY29tbWFuZC4gIFRvIGF2b2lkIHRoZSByZXBsYWNlbWVudCB1c2UKPGx0PiBpbiBwbGFjZSBvZiB0aGUgaW5pdGlhbCA8LiAgVGh1cyB0byBpbmNsdWRlICI8YmFuZz4iIGxpdGVyYWxseSB1c2UKIjxsdD5iYW5nPiIuCgpUaGUgdmFsaWQgZXNjYXBlIHNlcXVlbmNlcyBhcmUKCgkJCQkJCSo8bGluZTE+KgoJPGxpbmUxPglUaGUgc3RhcnRpbmcgbGluZSBvZiB0aGUgY29tbWFuZCByYW5nZS4KCQkJCQkJKjxsaW5lMj4qCgk8bGluZTI+CVRoZSBmaW5hbCBsaW5lIG9mIHRoZSBjb21tYW5kIHJhbmdlLgoJCQkJCQkqPGNvdW50PioKCTxjb3VudD4JQW55IGNvdW50IHN1cHBsaWVkIChhcyBkZXNjcmliZWQgZm9yIHRoZSAnLXJhbmdlJwoJCWFuZCAnLWNvdW50JyBhdHRyaWJ1dGVzKS4KCQkJCQkJKjxiYW5nPioKCTxiYW5nPgkoU2VlIHRoZSAnLWJhbmcnIGF0dHJpYnV0ZSkgRXhwYW5kcyB0byBhICEgaWYgdGhlCgkJY29tbWFuZCB3YXMgZXhlY3V0ZWQgd2l0aCBhICEgbW9kaWZpZXIsIG90aGVyd2lzZQoJCWV4cGFuZHMgdG8gbm90aGluZy4KCQkJCQkJKjxyZWc+KiAqPHJlZ2lzdGVyPioKCTxyZWc+CShTZWUgdGhlICctcmVnaXN0ZXInIGF0dHJpYnV0ZSkgVGhlIG9wdGlvbmFsIHJlZ2lzdGVyLAoJCWlmIHNwZWNpZmllZC4gIE90aGVyd2lzZSwgZXhwYW5kcyB0byBub3RoaW5nLiAgPHJlZ2lzdGVyPgoJCWlzIGEgc3lub255bSBmb3IgdGhpcy4KCQkJCQkJKjxhcmdzPioKCTxhcmdzPglUaGUgY29tbWFuZCBhcmd1bWVudHMsIGV4YWN0bHkgYXMgc3VwcGxpZWQgKGJ1dCBhcwoJCW5vdGVkIGFib3ZlLCBhbnkgY291bnQgb3IgcmVnaXN0ZXIgY2FuIGNvbnN1bWUgc29tZQoJCW9mIHRoZSBhcmd1bWVudHMsIHdoaWNoIGFyZSB0aGVuIG5vdCBwYXJ0IG9mIDxhcmdzPikuCgk8bHQ+CUEgc2luZ2xlICc8JyAoTGVzcy1UaGFuKSBjaGFyYWN0ZXIuICBUaGlzIGlzIG5lZWRlZCBpZiB5b3UKCQl3YW50IHRvIGdldCBhIGxpdGVyYWwgY29weSBvZiBvbmUgb2YgdGhlc2UgZXNjYXBlIHNlcXVlbmNlcwoJCWludG8gdGhlIGV4cGFuc2lvbiAtIGZvciBleGFtcGxlLCB0byBnZXQgPGJhbmc+LCB1c2UKCQk8bHQ+YmFuZz4uCgoJCQkJCQkJKjxxLWFyZ3M+KgpJZiB0aGUgZmlyc3QgdHdvIGNoYXJhY3RlcnMgb2YgYW4gZXNjYXBlIHNlcXVlbmNlIGFyZSAicS0iIChmb3IgZXhhbXBsZSwKPHEtYXJncz4pIHRoZW4gdGhlIHZhbHVlIGlzIHF1b3RlZCBpbiBzdWNoIGEgd2F5IGFzIHRvIG1ha2UgaXQgYSB2YWxpZCB2YWx1ZQpmb3IgdXNlIGluIGFuIGV4cHJlc3Npb24uICBUaGlzIHVzZXMgdGhlIGFyZ3VtZW50IGFzIG9uZSBzaW5nbGUgdmFsdWUuCldoZW4gdGhlcmUgaXMgbm8gYXJndW1lbnQgPHEtYXJncz4gaXMgYW4gZW1wdHkgc3RyaW5nLgoJCQkJCQkJKjxmLWFyZ3M+KgpUbyBhbGxvdyBjb21tYW5kcyB0byBwYXNzIHRoZWlyIGFyZ3VtZW50cyBvbiB0byBhIHVzZXItZGVmaW5lZCBmdW5jdGlvbiwgdGhlcmUKaXMgYSBzcGVjaWFsIGZvcm0gPGYtYXJncz4gKCJmdW5jdGlvbiBhcmdzIikuICBUaGlzIHNwbGl0cyB0aGUgY29tbWFuZAphcmd1bWVudHMgYXQgc3BhY2VzIGFuZCB0YWJzLCBxdW90ZXMgZWFjaCBhcmd1bWVudCBpbmRpdmlkdWFsbHksIGFuZCB0aGUKPGYtYXJncz4gc2VxdWVuY2UgaXMgcmVwbGFjZWQgYnkgdGhlIGNvbW1hLXNlcGFyYXRlZCBsaXN0IG9mIHF1b3RlZCBhcmd1bWVudHMuClNlZSB0aGUgTXljbWQgZXhhbXBsZSBiZWxvdy4gIElmIG5vIGFyZ3VtZW50cyBhcmUgZ2l2ZW4gPGYtYXJncz4gaXMgcmVtb3ZlZC4KICAgVG8gZW1iZWQgd2hpdGVzcGFjZSBpbnRvIGFuIGFyZ3VtZW50IG9mIDxmLWFyZ3M+LCBwcmVwZW5kIGEgYmFja3NsYXNoLgo8Zi1hcmdzPiByZXBsYWNlcyBldmVyeSBwYWlyIG9mIGJhY2tzbGFzaGVzIChcXCkgd2l0aCBvbmUgYmFja3NsYXNoLiAgQQpiYWNrc2xhc2ggZm9sbG93ZWQgYnkgYSBjaGFyYWN0ZXIgb3RoZXIgdGhhbiB3aGl0ZSBzcGFjZSBvciBhIGJhY2tzbGFzaApyZW1haW5zIHVubW9kaWZpZWQuICBPdmVydmlldzoKCgljb21tYW5kCQkgICA8Zi1hcmdzPiB+CglYWCBhYgkJICAgJ2FiJwoJWFggYVxiCQkgICAnYVxiJwoJWFggYVwgYgkJICAgJ2EgYicKCVhYIGFcICBiCSAgICdhICcsICdiJwoJWFggYVxcYgkJICAgJ2FcYicKCVhYIGFcXCBiCSAgICdhXCcsICdiJwoJWFggYVxcXGIJICAgJ2FcXGInCglYWCBhXFxcIGIJICAgJ2FcIGInCglYWCBhXFxcXGIJICAgJ2FcXGInCglYWCBhXFxcXCBiCSAgICdhXFwnLCAnYicKCkV4YW1wbGVzID4KCiAgICIgRGVsZXRlIGV2ZXJ5dGhpbmcgYWZ0ZXIgaGVyZSB0byB0aGUgZW5kCiAgIDpjb20gRGRlbCArLCRkCgogICAiIFJlbmFtZSB0aGUgY3VycmVudCBidWZmZXIKICAgOmNvbSAtbmFyZ3M9MSAtYmFuZyAtY29tcGxldGU9ZmlsZSBSZW4gZiA8YXJncz58dzxiYW5nPgoKICAgIiBSZXBsYWNlIGEgcmFuZ2Ugd2l0aCB0aGUgY29udGVudHMgb2YgYSBmaWxlCiAgICIgKEVudGVyIHRoaXMgYWxsIGFzIG9uZSBsaW5lKQogICA6Y29tIC1yYW5nZSAtbmFyZ3M9MSAtY29tcGxldGU9ZmlsZQoJIFJlcGxhY2UgPGxpbmUxPi1wdV98PGxpbmUxPiw8bGluZTI+ZHxyIDxhcmdzPnw8bGluZTE+ZAoKICAgIiBDb3VudCB0aGUgbnVtYmVyIG9mIGxpbmVzIGluIHRoZSByYW5nZQogICA6Y29tISAtcmFuZ2UgLW5hcmdzPTAgTGluZXMgIGVjaG8gPGxpbmUyPiAtIDxsaW5lMT4gKyAxICJsaW5lcyIKCiAgICIgQ2FsbCBhIHVzZXIgZnVuY3Rpb24gKGV4YW1wbGUgb2YgPGYtYXJncz4pCiAgIDpjb20gLW5hcmdzPSogTXljbWQgY2FsbCBNeWZ1bmMoPGYtYXJncz4pCgpXaGVuIGV4ZWN1dGVkIGFzOiA+Cgk6TXljbWQgYXJnMSBhcmcyClRoaXMgd2lsbCBpbnZva2U6ID4KCTpjYWxsIE15ZnVuYygiYXJnMSIsImFyZzIiKQoKICAgOiIgQSBtb3JlIHN1YnN0YW50aWFsIGV4YW1wbGUKICAgOmZ1bmN0aW9uIEFsbGFyZ3MoY29tbWFuZCkKICAgOiAgIGxldCBpID0gMAogICA6ICAgd2hpbGUgaSA8IGFyZ2MoKQogICA6CSAgaWYgZmlsZXJlYWRhYmxlKGFyZ3YoaSkpCiAgIDoJICAgICBleGVjdXRlICJlICIgLiBhcmd2KGkpCiAgIDoJICAgICBleGVjdXRlIGE6Y29tbWFuZAogICA6ICAgICAgZW5kaWYKICAgOiAgICAgIGxldCBpID0gaSArIDEKICAgOiAgIGVuZHdoaWxlCiAgIDplbmRmdW5jdGlvbgogICA6Y29tbWFuZCAtbmFyZ3M9KyAtY29tcGxldGU9Y29tbWFuZCBBbGxhcmdzIGNhbGwgQWxsYXJncyg8cS1hcmdzPikKClRoZSBjb21tYW5kIEFsbGFyZ3MgdGFrZXMgYW55IFZpbSBjb21tYW5kKHMpIGFzIGFyZ3VtZW50IGFuZCBleGVjdXRlcyBpdCBvbiBhbGwKZmlsZXMgaW4gdGhlIGFyZ3VtZW50IGxpc3QuICBVc2FnZSBleGFtcGxlIChub3RlIHVzZSBvZiB0aGUgImUiIGZsYWcgdG8gaWdub3JlCmVycm9ycyBhbmQgdGhlICJ1cGRhdGUiIGNvbW1hbmQgdG8gd3JpdGUgbW9kaWZpZWQgYnVmZmVycyk6ID4KCTpBbGxhcmdzICVzL2Zvby9iYXIvZ2V8dXBkYXRlClRoaXMgd2lsbCBpbnZva2U6ID4KCTpjYWxsIEFsbGFyZ3MoIiVzL2Zvby9iYXIvZ2V8dXBkYXRlIikKPApXaGVuIGRlZmluaW5nIGEgdXNlciBjb21tYW5kIGluIGEgc2NyaXB0LCBpdCB3aWxsIGJlIGFibGUgdG8gY2FsbCBmdW5jdGlvbnMKbG9jYWwgdG8gdGhlIHNjcmlwdCBhbmQgdXNlIG1hcHBpbmdzIGxvY2FsIHRvIHRoZSBzY3JpcHQuICBXaGVuIHRoZSB1c2VyCmludm9rZXMgdGhlIHVzZXIgY29tbWFuZCwgaXQgd2lsbCBydW4gaW4gdGhlIGNvbnRleHQgb2YgdGhlIHNjcmlwdCBpdCB3YXMKZGVmaW5lZCBpbi4gIFRoaXMgbWF0dGVycyBpZiB8PFNJRD58IGlzIHVzZWQgaW4gYSBjb21tYW5kLgoKIHZpbTp0dz03ODp0cz04OmZ0PWhlbHA6bm9ybDoK