PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iSVNPLTg4NTktMSI/Pg0KPCEtLQ0KLyogICBDb3B5cmlnaHQgMjAwNCBUaGUgQXBhY2hlIFNvZnR3YXJlIEZvdW5kYXRpb24NCiAqDQogKiAgIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSAiTGljZW5zZSIpOw0KICogICB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuDQogKiAgIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdA0KICoNCiAqICAgICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMA0KICoNCiAqICAgVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZQ0KICogICBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiAiQVMgSVMiIEJBU0lTLA0KICogICBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC4NCiAqICAgU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZA0KICogIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLg0KICovDQotLT4NCg0KPCEtLSA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KZWhkLVNjaG5pdHRzdGVsbGUgImVIZWFsdGhEYXRhIg0KRGllIEhhdXB0aW50ZW50aW9uIHZvbiBlaGQgaXN0IGVzLCBlaW5lbiBSYWhtZW4genUgc2NoYWZmZW4sIGluIGRlbSBiZWxpZWJpZ2UgWE1MLVNjaG5pdHRzdGVsbGVuIA0KZW50c3RlaGVuIGv2bm5lbiwgZvxyIGRpZSBkZXIgQ0RBLUhlYWRlciB2b24gU0NJUEhPWCB1bmdlZWlnbmV0IGlzdC4gRGFiZWkgd2lyZCBXZXJ0IGRhcmF1ZiANCmdlbGVndCwgd2VpdGdlaGVuZCBrb21wYXRpYmVsIHp1IFNDSVBIT1ggenUgc2VpbjogVm9uIGJlZ3L8bmRldGVuIEF1c25haG1lbiBhYmdlc2VoZW4sIA0Kd2VyZGVuIGb8ciBhbGxlIGVoZC1TY2huaXR0c3RlbGxlbiBkaWUgRWxlbWVudGUgYXVzIFNDSVBIT1gg/GJlcm5vbW1lbi4gDQoNCk5hbWVuc3JhdW0gaXN0OiAgdXJuOmVoZC8wMDENCg0KRGFtaXQgRWxlbWVudG5hbWVuIG5pY2h0IHVtZGVmaW5pZXJ0IHdlcmRlbiBr9m5uZW4sIGlzdCBibG9ja0RlZmF1bHQ9InN1YnN0aXR1dGlvbiIgZ2VzZXR6dC4NCkJlaSBBYmxlaXR1bmcgdm9uIG5ldWVuIFNjaG5pdHRzdGVsbGVuLCBpc3QgZGllc2VzIEF0dHJpYnV0IChibG9ja0RlZmF1bHQpIGF1Y2ggenUgc2V0emVuLg0KRGllIFZlcnNpb24gZGVyIFNjaG5pdHRzdGVsbGUgaXN0IGltIHZlcnNpb24tQXR0cmlidXQgaGludGVybGVndC4NCg0KdmVyc2lvbj0iMS4zMCINCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09LS0+DQo8eHM6c2NoZW1hIHhtbG5zPSJ1cm46ZWhkLzAwMSIgeG1sbnM6ZWhkPSJ1cm46ZWhkLzAwMSIgeG1sbnM6eHM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hIiB0YXJnZXROYW1lc3BhY2U9InVybjplaGQvMDAxIiBlbGVtZW50Rm9ybURlZmF1bHQ9InF1YWxpZmllZCIgYXR0cmlidXRlRm9ybURlZmF1bHQ9InVucXVhbGlmaWVkIiBibG9ja0RlZmF1bHQ9InN1YnN0aXR1dGlvbiIgdmVyc2lvbj0iMS4zMCI+DQoJPCEtLSA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSANCgllaGRfRGF0ZWllbiBlaW5iaW5kZW4NCgk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4NCgk8eHM6aW5jbHVkZSBzY2hlbWFMb2NhdGlvbj0ieG1sYmVhbnNfMTg0X2VoZF9oZWFkZXJfVjEuMzAueHNkXyIvPg0KCTx4czppbmNsdWRlIHNjaGVtYUxvY2F0aW9uPSJ4bWxiZWFuc18xODRfa2V5dGFic19WMS4zMC54c2RfIi8+DQoJPCEtLSA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSANCgllaGRfcm9vdF90eXANCgk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4NCgk8eHM6Y29tcGxleFR5cGUgbmFtZT0iZWhkX3Jvb3RfdHlwIj4NCgkJPHhzOnNlcXVlbmNlPg0KCQkJPHhzOmVsZW1lbnQgbmFtZT0iaGVhZGVyIiB0eXBlPSJlaGRfaGVhZGVyX3R5cCI+DQoJCQkJPHhzOmFubm90YXRpb24+DQoJCQkJCTx4czpkb2N1bWVudGF0aW9uPmFsbGUgTWV0YWluZm9ybWF0aW9uZW4genUgZGVuIERhdGVuPC94czpkb2N1bWVudGF0aW9uPg0KCQkJCTwveHM6YW5ub3RhdGlvbj4NCgkJCTwveHM6ZWxlbWVudD4NCgkJCTx4czplbGVtZW50IG5hbWU9ImJvZHkiIHR5cGU9ImVoZF9ib2R5X3R5cCI+DQoJCQkJPHhzOmFubm90YXRpb24+DQoJCQkJCTx4czpkb2N1bWVudGF0aW9uPmRpZSBlaWdlbnRsaWNoZW4gRGF0ZW48L3hzOmRvY3VtZW50YXRpb24+DQoJCQkJPC94czphbm5vdGF0aW9uPg0KCQkJPC94czplbGVtZW50Pg0KCQkJPHhzOmVsZW1lbnQgcmVmPSJrZXl0YWJzIiBtaW5PY2N1cnM9IjAiLz4NCgkJPC94czpzZXF1ZW5jZT4NCgkJPHhzOmF0dHJpYnV0ZSBuYW1lPSJlaGRfdmVyc2lvbiIgdHlwZT0iZWhkX3ZlcnNpb25fdHlwIiB1c2U9InJlcXVpcmVkIi8+DQoJPC94czpjb21wbGV4VHlwZT4NCgk8IS0tDQoJPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQoJVmVyc2lvbmllcnVuZyBkZXIgU2NoZW1hOg0KCWltIFNjaGVtYS1BdHRyaWJ1dCAidmVyc2lvbiIgc3RlaHQgaW1tZXIgZGllIGFrdHVlbGxlIFZlcnNpb25zbnVtbWVyLg0KCUltIFBmbGljaHRhdHRyaWJ1dCAiZWhkX3ZlcnNpb24iIHdpcmQgaW0gWE1MLURva3VtZW50IGRpZSBFSEQtVmVyc2lvbiANCglhbmdlZ2ViZW5lbiwgbWl0IGRlciBkYXMgRG9rdW1lbnQgZXJzdGVsbHQgd3VyZGUuIEVpbiBiZXN0aW1tdGVyIFdlcnQgd2lyZCANCgloaWVyIGJld3XfdCBuaWNodCB2b3JnZWdlYmVuLCBkYW1pdCBiZWkgZ2VyaW5nZvxnaWdlbiDEbmRlcnVuZ2VuLCBub2NoIA0KCUF1ZnfkcnRza29tcGF0aWJpbGl05HQgZ2V35GhybGVpc3RldCB3ZXJkZW4ga2Fubi4NCgk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0tLT4NCgk8eHM6c2ltcGxlVHlwZSBuYW1lPSJlaGRfdmVyc2lvbl90eXAiPg0KCQk8eHM6cmVzdHJpY3Rpb24gYmFzZT0ieHM6ZGVjaW1hbCI+DQoJCQk8eHM6cGF0dGVybiB2YWx1ZT0iXGQ/XGRcLlxkXGQiLz4NCgkJPC94czpyZXN0cmljdGlvbj4NCgk8L3hzOnNpbXBsZVR5cGU+DQoJPCEtLQ0KCT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KCWVoZF9ib2R5X3R5cCwgIGhpZXIga/ZubmVuIGRpZSBTY2huaXR0c3RlbGxlbnNwZXppZmlzY2hlbiBFbGVtZW50ZSB1LiBBdHRyaWJ1dGUNCglkZWZpbmllcnQgd2VyZGVuLiBXZW5uIGRlciBQYXJzZXIgZGllIG5ldWVuIEVsZW1lbnRlIG5pY2h0IGtlbm50LCB3aXJkDQoJa2VpbmUgRmVobGVybWVsZHVuZyBhdXNnZWdlYmVuLiBXZW5uIGRpZSBFbGVtZW50ZGVmaW5pdGlvbiBqZWRvY2ggdm9yaGFuZGVuDQoJaXN0LCBhYmVyIGRpZSBTdHJ1a3R1ciBpbiBkZXIgWE1MLUluc3RhbmNlIG5pY2h0IGVpbmdlaGFsdGVuIHdpcmQsIG1lbGRldA0KCWRlciBQYXJzZXIgZWluZW4gRmVobGVyLg0KCT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KCS0tPg0KCTx4czpjb21wbGV4VHlwZSBuYW1lPSJlaGRfYm9keV90eXAiPg0KCQk8eHM6Y2hvaWNlIG1pbk9jY3Vycz0iMCIgbWF4T2NjdXJzPSJ1bmJvdW5kZWQiPg0KCQkJPHhzOmFueSBwcm9jZXNzQ29udGVudHM9InNraXAiIG1pbk9jY3Vycz0iMCIgbWF4T2NjdXJzPSJ1bmJvdW5kZWQiLz4NCgkJPC94czpjaG9pY2U+DQoJPC94czpjb21wbGV4VHlwZT4NCjwveHM6c2NoZW1hPg0K