PGh0bWw+CjxoZWFkPgo8dGl0bGU+U3Bpcml0IENoYW5nZSBMb2c8L3RpdGxlPgo8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIj4KPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJkb2MvdGhlbWUvc3R5bGUuY3NzIiB0eXBlPSJ0ZXh0L2NzcyI+CjwvaGVhZD4KCjxib2R5PgoKPGgyPlNwaXJpdCBDaGFuZ2UgTG9nPC9oMj4KPGgyPjEuOC43PC9oMj4KPHVsPgogIDxsaT5JbnRlZ3JhdGVkIHRoZSBTcGlyaXQgVjEuOC54IGNvZGUgYmFzZSB3aXRoIFNwaXJpdCBWMi4gU3Bpcml0IFYxLjgueCBpcwogICAgICBub3cgY2FsbGVkIAogICAgPHN0cm9uZz5TcGlyaXQgQ2xhc3NpYy48L3N0cm9uZz4gRXZlbiBpZiB0aGUgZGlyZWN0b3J5CiAgICAgIHN0cnVjdHVyZSBoYXMgY2hhbmdlZCAodGhlIAogICAgPHN0cm9uZz5TcGlyaXQgQ2xhc3NpYzwvc3Ryb25nPiBoZWFkZXJzIGFyZSBub3cgbW92ZWQgdG8gdGhlIAogICAgICAnJEJPT1NUX1JPT1QvYm9vc3Qvc3Bpcml0L2hvbWUvY2xhc3NpYycgZGlyZWN0b3J5KSwgd2UgY3JlYXRlZCBmb3J3YXJkaW5nIAogICAgICBoZWFkZXJzIGFsbG93aW5nIHRvIGNvbXBpbGUgZXhpc3RpbmcgYXBwbGljYXRpb25zIHdpdGhvdXQgYW55IGNoYW5nZS4gCiAgICAgIFRoZXNlIGZvcndhcmRpbmcgaGVhZGVycyBhcmUgZGVwcmVjYXRlZCwgdGhvdWdoLCB3aGljaCB3aWxsIHJlc3VsdCBpbiAKICAgICAgY29ycmVzcG9uZGluZyB3YXJuaW5ncyBnZW5lcmF0ZWQgZm9yIGVhY2ggb2YgdGhlIGhlYWRlcnMuIFRoZSBmb3J3YXJkaW5nIAogICAgICBoZWFkZXJzIGFyZSBleHBlY3RlZCB0byBiZSByZW1vdmVkIGluIHRoZSBmdXR1cmUuCiAgICA8YnIgLz4KICAgICAgVGhlIHJlY29tbWVuZGVkIHdheSBvZiB1c2luZyBTcGlyaXQgQ2xhc3NpYyBpcyBub3cgdG8gaW5jbHVkZSBoZWFkZXIKICAgICAgZmlsZXMgZnJvbSB0aGUgZGlyZWN0b3J5ICckQk9PU1RfUk9PVC9ib29zdC9zcGlyaXQvaW5jbHVkZScuIEFsbCBmaWxlcyBvZiAKICAgICAgPHN0cm9uZz5TcGlyaXQgQ2xhc3NpYzwvc3Ryb25nPgogICAgICBoYXZlIG5vdyBhICdjbGFzc2ljXycgcHJlZml4ZWQgdG8gdGhlaXIgbmFtZS4gRm9yIGV4YW1wbGUgdGhlIGluY2x1ZGUKICAgIDxici8+CiAgICAgIDxicj48Y29kZT4mbmJzcDsmbmJzcDsjaW5jbHVkZSAmbHQ7Ym9vc3Qvc3Bpcml0L2NvcmUvY29yZS5ocHAmZ3Q7PC9jb2RlPjxici8+IAogICAgPGJyLz4KICAgIG5vdyBzaG91bGQgYmUgd3JpdHRlbiBhczogCiAgICA8YnIvPgogICAgICAgPGJyLz48Y29kZT4mbmJzcDsmbmJzcDsjaW5jbHVkZSAmbHQ7Ym9vc3Qvc3Bpcml0L2luY2x1ZGUvY2xhc3NpY19jb3JlLmhwcCZndDs8L2NvZGU+PGJyLz4KICAgIDxici8+ICAgICAgCiAgICBUbyBhdm9pZCBuYW1lc3BhY2UgY29uZmxpY3RzIHdpdGggdGhlIG5ldyBTcGlyaXQgVjIgbGlicmFyeSB3ZSBtb3ZlZCA8c3Ryb25nPlNwaXJpdAogICAgICBDbGFzc2ljPC9zdHJvbmc+IGludG8gdGhlIDx0dD5uYW1lc3BhY2UgYm9vc3Q6OnNwaXJpdDo6Y2xhc3NpYzwvdHQ+LiBUaGlzIGNoYW5nZSB3aWxsIGJlIGF1dG9tYXRpY2FsbHkmbmJzcDtkZWFjdGl2YXRlZCB3aGVuZXZlciB0aGUgZGVwcmVjYXRlZCBpbmNsdWRlIGZpbGVzIGFyZQogICAgYmVpbmcgdXNlZC4gVGhpcyBlbnN1cmVzIGZ1bGwgYmFja3dhcmRzIGNvbXBhdGliaWxpdHkgZm9yIGV4aXN0aW5nIGFwcGxpY2F0aW9ucy4KICAgIDxiciAvPgogICAgRm9yIG1vcmUgZGV0YWlscyBhYm91dCB0aGlzIGNoYW5nZSBwbGVhc2UgY29uc3VsdCB0aGUgZG9jdW1lbnRhdGlvbi48L2xpPgo8L3VsPgo8aDI+MS44LjY8L2gyPgo8dWw+CiAgPGxpPkZpeGVkIGEgaW50ZWdlciBvdmVyZmxvdyBidWcgcHJldmVudGluZyB0byBmYWlsIHBhcnNpbmcgb24gY2VydGFpbiBsYXJnZSBpbnRlZ2Vycy4gVGhpcyBidWcgd2FzIHJlcG9ydGVkIGFuZCBmaXhlZCBieSBNaWNoYWVsIEFuZGVyc2VuIE5lePg8L2xpPgo8L3VsPgo8aDI+MS44LjU8L2gyPgo8dWw+CiAgPGxpPkZvciBwZXJmb3JtYW5jZSByZWFzb25zLCBsZWFmX25vZGVfZC90b2tlbl9ub2RlX2QgaGF2ZSBiZWVuIGNoYW5nZWQgdG8gaW1wbGljaXQgbGV4ZW1zIHRoYXQgY3JlYXRlIGxlYWYgbm9kZXMgaW4gb25lIHNob3QuIFRoZSBvbGQgdG9rZW5fbm9kZV9kIGlzIHN0aWxsIGF2YWlsYWJsZSBhbmQgY2FsbGVkIHJlZHVjZWRfbm9kZV9kLCBub3cuPC9saT4KICA8bGk+SXQncyBub3cgcG9zc2libGUgdG8gcGhvZW5peDo6YmluZCAodmVyc2lvbiAxKSBzeW1ib2xzOjphZGQuPC9saT4KPC91bD4KPGgyPjEuOC40PC9oMj4KPHVsPgogIDxsaT5GaXhlZCBub19hY3Rpb25zIGJ1ZyB3aGVyZSBub19hY3Rpb24gaXMgYXBwbGllZCByZWN1cnNpdmVseS48L2xpPgogIDxsaT5GaXhlZCB0aGUgcmVnZXhfcCBwYXJzZXIgZm9yIEJvb3N0ICZndDs9IFYxLjMzLjAgPC9saT4KICA8bGk+SW1wbGVtZW50ZWQgYSB3b3JrYXJvdW5kIGZvciBuYW1lc3BhY2UgaXNzdWVzIFZDKysgaGFzIHdpdGggU3Bpcml0J3MgZmlsZV9pdGVyYXRvcnM8L2xpPgogIDxsaT5GaXhlZCBidWcgaW4gdHJlZSBtYXRjaCBwb2xpY2llcyB0aGF0IHByZXZlbnRlZCB1c2luZyBnZW5fcHQvYXN0X25vZGVfZCwKICAgIDxhIGhyZWY9Imh0dHA6Ly9hcnRpY2xlLmdtYW5lLm9yZy9nbWFuZS5jb21wLnBhcnNlcnMuc3Bpcml0LmdlbmVyYWwvOTAxMyI+cmVwb3J0ZWQKICAgIGJ5IEphc2NoYSBXZXR6ZWw8L2E+LjwvbGk+CiAgPGxpPk1hZGUgcG9zaXRpb25faXRlcmF0b3IgdXNhYmxlIHdpdGggd2NoYXJfdCBiYXNlZCBzdHJpbmdzLiA8L2xpPgo8L3VsPgo8aDI+MS44LjM8L2gyPgo8dWw+CiAgPGxpPkNvbmZpZyBjb3JyZWN0aW9uIGZvciBTdW4gQysrIGJ5IAoKCiBTdGV2ZSBDbGFtYWdlIChzZWUgPGEgaHJlZj0iaHR0cHM6Ly9zb3VyY2Vmb3JnZS5uZXQvdHJhY2tlci8/ZnVuYz1kZXRhaWwmYXRpZD0xMDc1ODYmYWlkPTEyMjA3ODImZ3JvdXBfaWQ9NzU4NiI+dGhpcyBsaW5rPC9hPikuIDwvbGk+CiAgPGxpPkZpeGVkIG11bHRpX3Bhc3NfaXRlcmF0b3IgZm9yIDY0IHBsYXRmb3Jtcywgd2hlcmUgc2l6ZW9mKGludCkgIT0gc2l6ZW9mKHB0cl90eXBlKS5GaXhlZCBidWcgdGhhdCBwcmV2ZW50cyB0aGUgdXNlIG9mIGNsb3N1cmVzIHdpdGggZ3JhbW1hcnMgd2l0aCBtdWx0aXBsZSBlbnRyeSBwb2ludHMsIDxhIGhyZWY9Imh0dHA6Ly9hcnRpY2xlLmdtYW5lLm9yZy9nbWFuZS5jb21wLnBhcnNlcnMuc3Bpcml0LmdlbmVyYWwvODg2OCI+cmVwb3J0ZWQgYnkgRGF2aWQgUGllcnJlPC9hPjwvbGk+CiAgPGxpPkZpeGVkIGJ1ZyB0aGF0IHByZXZlbnRlZCBlbWJlZGRpbmcgb2YgZ3JhbW1hcnMgd2l0aCBtdWx0aXBsZSBlbnRyeSBwb2ludHMsIDxhIGhyZWY9Imh0dHA6Ly9hcnRpY2xlLmdtYW5lLm9yZy9nbWFuZS5jb21wLnBhcnNlcnMuc3Bpcml0LmdlbmVyYWwvODg2MCI+cmVwb3J0ZWQgYnkgRGF2aWQgUGllcnJlPC9hPjwvbGk+CiAgPGxpPkFkZGVkICdcMCcgdG8gdGhlIHNldCBvZiB2YWxpZCBlc2NhcGVkIGNoYXJhY3RlcnMgZm9yIGVzY2FwZV9jaF9wLjwvbGk+CiAgPGxpPkZpeGVkIGEgc3dpdGNoX3AgYnVnIHdoZW4gdXNlZCB3aXRoIGEgcGhvZW5peDo6YWN0b3IgYXMgdGhlIGNvbmRpdGlvbmFsIGV4cHJlc3Npb24uPC9saT4KICA8bGk+X19MSU5FX18gbWFjcm8gbm93IGdldHMgZXhwYW5kZWQgaW4gQk9PU1RfU1BJUklUX0FTU0VSVF9FWENFUFRJT048L2xpPgogIDxsaT5GaXhlZCBhIGJ1ZyBpbiB0aGUgaW50ZXJzZWN0aW9uIHBhcnNlciA8YSBocmVmPSJodHRwOi8vYXJ0aWNsZS5nbWFuZS5vcmcvZ21hbmUuY29tcC5wYXJzZXJzLnNwaXJpdC5nZW5lcmFsLzg1NDQiPnJlcG9ydGVkIGJ5IFl1c2FrdSBTdWdhaTwvYT48L2xpPgogIDxsaT5UaGUgc3ltYm9sIHBhcnNlciB1c2VzIHRoZSBudWxsIGNoYXJhY3RlciBpbnRlcm5hbGx5LiBDaGVja3Mgd2VyZSBhZGRlZCBzbyB0aGF0OgogIDx1bD4KICAgIDxsaT50c3QuYWRkIGFzc2VydHMgaWYgc3RyaW5nIGNvbnRhaW5zIHRoZSBudWxsIGNoYXJhY3RlcjwvbGk+CiAgICA8bGk+dHN0LmZpbmQgZG9lc24ndCBtYXRjaCBudWxsIGNoYXJhY3RlcnMgaW4gdGhlIGlucHV0PC9saT4KICA8L3VsPjwvbGk+CiAgPGxpPkZpeGVkIG1hdGNoX2F0dHJfdHJhaXRzLmlwcCB0byBhbGxvdyBub24tUE9EIHRvIHBhc3MgdGhyb3VnaC4gVGhlIHByZXZpb3VzIHZlcnNpb24gdGFraW5nIGluIHRoZSBlbGxpcHNpcyAmcXVvdDsuLi4mcXVvdDsgZG9lcyBub3QgYWxsb3cgUE9EcyB0byBwYXNzIHRocm91Z2guPC9saT4KICA8bGk+QWxsb3cgZXZhbHVhdGlvbiB0byBpbnQgYXMgY29uZGl0aW9uIHRvIGlmX3AgcGFyc2VyLjwvbGk+CiAgPGxpPkFwcGxpZWQgIHBlcmZvcm1hbmNlIGltcHJvdmVtZW50IGNoYW5nZXMgdG8gdGhlIFBUL0FTVCBjb2RlIGFzIHN1Z2dlc3RlZCBieSBTdGVmYW4gU2xhcGV0YS4gPC9saT4KICA8bGk+Rml4ZWQgc2V2ZXJhbCBwcm9ibGVtcyB3aXRoIEFTVCB0cmVlIG5vZGUgZGlyZWN0aXZlcyAoaW5uZXJfbm9kZV9kW10sIGRpc2NhcmRfZmlyc3Rfbm9kZVtdLCBkaXNjYXJkX2xhc3Rfbm9kZVtdIGFuZCBpbmZpeF9ub2RlX2RbXSkuIDwvbGk+CjwvdWw+CjxoMj4xLjguMjwvaDI+CjxwPk1haW50ZW5hbmNlIHJlbGVhc2UgKGFsbW9zdCB0aGUgc2FtZSBhcyAxLjguMSBwbHVzIGEgZmV3IGZpeGVzIGhlcmUgYW5kIHRoZXJlKTwvcD4KPHVsPgogIDxsaT5BZGRlZCBzcGVjaWFsaXphdGlvbnMgdG8gc3RyX3AgYW5kIGNoX3AgdG8gYWxsb3cgc3RyX3AoJ2MnKSBhbmQgY2hfcCgiYyIpIHRodXMgZml4aW5nIHNvbWUgbm9uLWJ1Z3M8L2xpPgogIDxsaT5GaXhlZCBidWcgd2hlcmUgYSBtYXRjaCZsdDtUJmd0OyBpcyBhIHZhcmlhbnQuPC9saT4KICA8bGk+YWRkZWQgSmFtZmlsZS9KYW1ydWxlcyBmcm9tIENWUyB0byBzcGlyaXQtMS44LjEvPC9saT4KICA8bGk+YWRkZWQgYm9vc3QtYnVpbGQuamFtIGZyb20gYm9vc3QgdG8gc3Bpcml0LTEuOC4xLzwvbGk+CiAgPGxpPmRpc2FibGVkIHRlbXBsYXRlIG11bHRpLXRocmVhZGluZyBpbiBsaWJzL3NwaXJpdC90ZXN0L0phbWZpbGU8L2xpPgogIDxsaT5hZGRlZCBhIGJvb3N0LWhlYWRlci1pbmNsdWRlIHJ1bGUgKGZyb20gc3Bpcml0LWhlYWRlci1pbmNsdWRlKSBwb2ludGluZyB0byBtaW5pYm9vc3QgaW4gbGlicy9zcGlyaXQvdGVzdC9KYW1maWxlPC9saT4KICA8bGk+Rml4ZWQgaWZfcCBpbmNvbnNpc3RlbmN5PC9saT4KPC91bD4KPGgyPjEuNi4yPC9oMj4KPHA+VGhlIFNwaXJpdCAxLjYuMiByZWxlYXNlIGlzIGEgYnVnLWZpeCByZWxlYXNlIG9ubHksIG5vIG5ldyBmZWF0dXJlcyB3ZXJlIGludHJvZHVjZWQuPC9wPgo8dWw+CiAgPGxpPndjaGFyX3QgZnJpZW5kbHkgaW1wbGVtZW50YXRpb24gb2YgZ3JhcGhfcDwvbGk+CiAgPGxpPk1vZGlmaWVkIGVzY2FwZV9jaGFyX3BhcnNlcjo6cGFyc2UoKSB0byB1c2UgYSBzdGF0aWMgcGFyc2VyIGluc3RlYWQgb2YgYSBydWxlLiBUaGlzIHdpbGwgbWFrZSBpdCBtb3JlIGZyaWVuZGx5IHRvIHVzZSBpbiB0cmVlcy4gSXQgc2hvdWxkIGFsc28gYmUgYSBsaXR0bGUgbW9yZSBlZmZpY2llbnQuPC9saT4KICA8bGk+TW92ZWQgdG8gCgoKIEJvb3N0IFNvZnR3YXJlIGxpY2Vuc2UgMS4wLiA8L2xpPgogIDxsaT4gd29ya2Fyb3VuZCBmb3IgRXJyb3IgMzIyIG5hbWUgbG9va3VwIGluIGJhc2UgY2xhc3Mgc3BlY2lhbGl6YXRpb24gZmluZHMgdHlwZTwvbGk+CiAgPGxpPiBmaXhlZCBsaW1pdF9kIGJ1ZzwvbGk+CiAgPGxpPiBbbnVtZXJpY3NdIFdvcmthcm91bmQgZm9yIGFDKys8L2xpPgogIDxsaT4gRml4ZWQgYSBidWcgaW4gdGhlIHN3aXRjaF9wIHBhcnNlci48L2xpPgogIDxsaT4gRml4ZWQgYSBFT0kgcHJvYmxlbSBpbiBtdWx0aV9wYXNzPC9saT4KICA8bGk+YWRkZWQgSmFtZmlsZS9KYW1ydWxlcyBmcm9tIENWUyB0byBzcGlyaXQtMS42LjEvPC9saT4KICA8bGk+YWRkZWQgYm9vc3QtYnVpbGQuamFtIGZyb20gYm9vc3QgdG8gc3Bpcml0LTEuNi4xLzwvbGk+CiAgPGxpPmRpc2FibGVkIHRlbXBsYXRlIG11bHRpLXRocmVhZGluZyBpbiBsaWJzL3NwaXJpdC90ZXN0L0phbWZpbGU8L2xpPgogIDxsaT5hZGRlZCBhIGJvb3N0LWhlYWRlci1pbmNsdWRlIHJ1bGUgKGZyb20gc3Bpcml0LWhlYWRlci1pbmNsdWRlKSBwb2ludGluZyB0byBtaW5pYm9vc3QgaW4gbGlicy9zcGlyaXQvdGVzdC9KYW1maWxlPC9saT4KPC91bD4KPGgyPjEuOC4xIChSZWxlYXNlZCB3aXRoIEJvb3N0IDEuMzIuMCk8L2gyPgo8cD5UaGUgU3Bpcml0IDEuOC4xIHJlbGVhc2UgaXMgYSBidWctZml4IHJlbGVhc2Ugb25seSwgbm8gbmV3IGZlYXR1cmVzIHdlcmUgaW50cm9kdWNlZC48L3A+Cjx1bD4KICA8bGk+U3Bpcml0IG5vdyByZXF1aXJlcyBhdCBsZWFzdCBCb29zdCAxLjMyLjAgdG8gY29tcGlsZSBjb3JyZWN0bHk8L2xpPgogIDxsaT5SZW1vdmVkIHRoZSBzdXBwb3J0IGZvciB0aGUgb2xkZXIgaXRlcmF0b3IgYWRhcHRvciBsaWJyYXJ5IGFuZCA8L2xpPgogIDxsaT5Nb3ZlZCB0byB1c2UgdGhlIG5ldyBNUEwgbGlicmFyeTwvbGk+CiAgPGxpPlNwaXJpdCB3YXMgbW92ZWQgdG8gdXNlIHRoZSBCb29zdCBTb2Z0d2FyZSBMaWNlbnNlIDEuMC48L2xpPgogIDxsaT5GaXhlZCBzZXZlcmFsIHBhcnNlcnMgdG8gc3VwcG9ydCBwb3N0LXNraXBzIG1vcmUgY29ycmVjdGx5LjwvbGk+CiAgPGxpPkZpeGVkIGEgbm9fbm9kZV9kW10gYnVnLjwvbGk+CiAgPGxpPkZpeGVkIGEgYnVnIGluIHNob3J0ZXN0X2RbXS48L2xpPgogIDxsaT5GaXhlZCBhIGJ1ZyBpbiBsaW1pdF9kW10uPC9saT4KICA8bGk+Rml4ZWQgcGFyc2VyIHRyYXZlcnNhbCBtZXRhIGNvZGUuPC9saT4KICA8bGk+Rml4ZWQgc2V2ZXJhbCBidWdzIGluIHN3aXRjaF9wLjwvbGk+CiAgPGxpPkZpeGVkIEFTVCBnZW5lcmF0aW5nIHByb2JsZW1zLCBpbiBwYXJ0aWN1bGFyIHdpdGggdGhlIGxvb3BzIHJlbGF0ZWQgcGFyc2Vycy48L2xpPgogIDxsaT5GaXhlZCBzZXZlcmFsIGJ1Z3MgaW4gdGhlIG11bHRpX3Bhc3MgaXRlcmF0b3IuCiAgICAgIDx1bD4KICAgICAgICA8bGk+Rml4ZWQgYSBwcm9ibGVtLCB3aGVuIHRoZSB1c2VkIGJhc2UgaXRlcmF0b3IgcmV0dXJuZWQgYSB2YWx1ZV90eXBlIGFuZCBub3QgYSByZWZlcmVuY2UgZnJvbSBpdHMgZGVyZWZlcmVuY2luZyBvcGVyYXRvci48L2xpPgogICAgICAgIDxsaT5GaXhlZCBpdGVyYXRvcl90cmFpdHMgcHJvYmxlbTwvbGk+CiAgICAgICAgPGxpPkZpeGVkIGFuIEVPSSBwcm9ibGVtPC9saT4KICAgICAgICA8bGk+Rml4ZWQgYSBidWcsIHdoZW4gdXNlZCB3aXRoIHN0ZDo6Y2luPC9saT4KICAgICAgPC91bD4KICA8L2xpPgogIDxsaT5Gb3VuZCBhIGJ1ZyBpbiBncmFtbWFyLmlwcCB3aGVuIEJPT1NUX1NQSVJJVF9TSU5HTEVfR1JBTU1BUl9JTlNUQU5DRSBpcyBkZWZpbmVkPC9saT4KICA8bGk+UmV3cml0dGVuIHNhZmVfYm9vbCB0byB1c2UgQ1JUUCAtIG5vdyB3b3JrcyBhbHNvIG9uIE1XQ1csIGZpeGVkIHNldmVyYWwgYnVncyB3aXRoIHRoZSBpbXBsZW1lbnRhdGlvbi48L2xpPgogIDxsaT5GaXhlZCBhbmQgZXh0ZW5kZWQgdGhlIGRlYnVnIGRpYWdub3N0aWNzIHByaW50ZWQgYnkgdGhlIHBhcnNlIHRyZWUgY29kZS48L2xpPgo8L3VsPgo8aDI+MS44LjAgKFJlbGVhc2VkIHdpdGggQm9vc3QgMS4zMS4wOyBJbmNsdWRlcyB1bnJlbGVhc2VkIDEuNy4xKTwvaDI+Cjx1bD4KICA8bGk+Rml4ZWQgYSB3Y2hhcl90IHByb2JsZW0gaW4gdGhlIHJlZ2V4X3AgcGFyc2VyLjwvbGk+CiAgPGxpPnJlbW92ZWQgY29kZSBhbmQgd29ya2Fyb3VuZHMgZm9yIG9sZCBjb21waWxlcnMgKFZDNi83IGFuZCBCb3JsYW5kKTwvbGk+CiAgPGxpPiBDaGFuZ2VkIGxpY2Vuc2UgdG8gdGhlIG5ldyBib29zdCBsaWNlbnNlLjwvbGk+CiAgPGxpPiBNb2RpZmllZCBlc2NhcGVfY2hhcl9wYXJzZXI6OnBhcnNlKCkgdG8gdXNlIGEgc3RhdGljIHBhcnNlciBpbnN0ZWFkIG9mIGEgcnVsZS4gVGhpcyB3aWxsIG1ha2UgaXQgbW9yZSBmcmllbmRseSB0byB1c2UgaW4gdHJlZXMuIEl0IHNob3VsZCBhbHNvIGJlIGEgbGl0dGxlIG1vcmUgZWZmaWNpZW50LjwvbGk+CjwvdWw+CjxoMj4xLjcuMSAoVW5yZWxlYXNlZDsgYmVjb21lcyAxLjguMCk8L2gyPgo8dWw+CiAgPGxpPkFkZGVkIGEgZnVsbCBzdWl0ZSBvZiBwcmVkZWZpbmVkIGFjdG9ycy48L2xpPgogIDxsaT5Nb3ZlZCBydWxlX2FsaWFzIGFuZCBzdG9yZWRfcnVsZSBmcm9tIGNvcmUvbm9uLXRlcm1pbmFsIHRvIGR5bmFtaWMuPGJyPgogICAgTWFkZSBhc19wYXJzZXIgYSBwdWJsaWMgQVBJIGluIG1ldGEvYXNfcGFyc2VyLmhwcDwvbGk+CiAgPGxpPlNlcGFyYXRlZCBDb3JlLk1ldGEgaW50byBpdHMgb3duIG1vZHVsZTwvbGk+CiAgPGxpPlJlZmFjdG9yZWQgVXRpbGl0eSBtb2R1bGU8YnI+CiAgICBNb3ZlZCBzb21lIGZpbGVzIGludG8gVXRpbGl0eS5QYXJzZXJzPC9saT4KPC91bD4KPGJsb2NrcXVvdGU+CiAgPHVsPgogICAgPGxpPnV0aWxpdGllcwogICAgICA8dWw+CiAgICAgICAgPGxpPnBhcnNlcnMKICAgICAgICAgIDx1bD4KICAgICAgICAgICAgPGxpPmNoc2V0LCByZWdleCwgZXNjYXBlX2NoYXI8YnI+CiAgICAgICAgICAgICAgY29uZml4LCBsaXN0LCBkaXN0aW5jdDxicj4KICAgICAgICAgICAgICBmdW5jdG9yX3BhcnNlcjwvbGk+CiAgICAgICAgICA8L3VsPgogICAgICAgIDwvbGk+CiAgICAgIDwvdWw+CiAgICA8L2xpPgogICAgPGxpPiBzdXBwb3J0CiAgICAgIDx1bD4KICAgICAgICA8bGk+c2NvcGVkX2xvY2s8YnI+CiAgICAgICAgICBmbHVzaF9tdWx0aV9wYXNzPGJyPgogICAgICAgICAgZ3JhbW1hcl9kZWY8L2xpPgogICAgICA8L3VsPgogICAgPC9saT4KICAgIDxsaT4gYWN0b3JzCiAgICAgIDx1bD4KICAgICAgICA8bGk+YXNzaWduPC9saT4KICAgICAgPC91bD4KICAgIDwvbGk+CiAgPC91bD4KPC9ibG9ja3F1b3RlPgo8dWw+CiAgPGxpPlN0b3JlZCBydWxlczwvbGk+CiAgPGxpPkFkZGVkIHRoZSBzd2l0Y2hfcCBhbmQgc2VsZWN0X3AgZHluYW1pYyBwYXJzZXJzLjwvbGk+CiAgPGxpPk11bHRpcGxlIHNjYW5uZXIgc3VwcG9ydCBmb3IgcnVsZXMuPC9saT4KICA8bGk+VGhlIFJ1bGUncyBTY2FubmVyLCBDb250ZXh0IGFuZCBUYWcgdGVtcGxhdGUgcGFyYW1ldGVycyBjYW4gYmUgc3BlY2lmaWVkIGluIGFueSBvcmRlciBub3cuIElmIGEgdGVtcGxhdGUgcGFyYW1ldGVyIGlzIG1pc3NpbmcsIGl0IHdpbGwgYXNzdW1lIHRoZSBkZWZhdWx0cy4gU2VlIHRlc3QvcnVsZV90ZXN0cy5jcHAuPC9saT4KICA8bGk+SW50cm9kdWNlZCB0aGUgcG9zc2liaWxpdHkgdG8gc3BlY2lmeSBtb3JlIHRoYW4gb25lIHN0YXJ0IHJ1bGUgZnJvbSBhIGdyYW1tYXIuPC9saT4KICA8bGk+QWRkZWQgYW4gaW1wbGVtZW50YXRpb24gb2YgdGhlIGZpbGVfaXRlcmF0b3IgaXRlcmF0b3IgYmFzZWQgb24gdGhlIG5ldyBCb29zdCBpdGVyYXRvcl9hZGFwdG9ycyAoc3VibWl0dGVkIG9yaWdpbmFsbHkgYnkgVGhvbWFzIFdpdHQpLjwvbGk+CjwvdWw+CjxwPjxlbT4gW1RoZSB0cmFuc2l0aW9uIHRvIHRoZSBuZXcgaXRlcmF0b3JfYWRhcHRvcnMgc2hvdWxkIGJlIGNvbXBsZXRlIG5vdy5dPC9lbT48L3A+Cjx1bD4KICA8bGk+QWRkZWQgYW4gaW1wbGVtZW50YXRpb24gb2YgdGhlIGZpeGVkX3NpemVfcXVldWUgaXRlcmF0b3IgYmFzZWQgb24gdGhlIG5ldyBCb29zdCBpdGVyYXRvcl9hZGFwdG9ycy48L2xpPgogIDxsaT4gd2NoYXJfdCBmcmllbmRseSBpbXBsZW1lbnRhdGlvbiBvZiBncmFwaF9wPC9saT4KICA8bGk+bWFkZSB0aGUgY29weS1jb25zdHJ1Y3RvciBhbmQgYXNzaWdubWVudC1vcGVyYXRvciBvZiBwYXJzZXJfZXJyb3JfYmFzZSBwdWJsaWMgdG8gY2xlYXIgVkM3LjEgQzQ2NzMgd2FybmluZy4gQWRkZWQgY29weS1jb25zdHJ1Y3RvciBhbmQgYXNzaWdubWVudCBvcGVyYXRvciB0byBwYXJzZXJfZXJyb3IgZm9yIGNsYXJpdHkgb2YgaW50ZW50LjwvbGk+CjwvdWw+CjxoMj4xLjcuMDwvaDI+Cjx1bD4KICA8bGk+IGFzc2lnbihzdHJpbmcpIHNlbWFudGljIGFjdGlvbiBub3cgd29ya3MgaW4gVkM2PC9saT4KICA8bGk+cGFyc2VycyBuZWVkIG5vdCBiZSBkZWZhdWx0IGNvbnN0cnVjdGlibGUgPC9saT4KICA8bGk+c2ltcGxpZmllZCBhZ2dyZWdhdGlvbiBvZiBiaW5hcnkgYW5kIHVuYXJ5IHBhcnNlcnMgKG1vcmUgY29tcGlsZXIgZnJpZW5kbHkpPC9saT4KICA8bGk+ZXBzaWxvbiB3b3JrYXJvdW5kcyBmb3IgVkMrKzwvbGk+CiAgPGxpPm1hdGNoJ3MgYXR0cmlidXRlIG5vdyB1c2VzIGJvb3N0Lm9wdGlvbmFsPC9saT4KICA8bGk+c3VicnVsZXMgY2FuIG5vdyBoYXZlIGNsb3N1cmVzPC9saT4KICA8bGk+cHJvamVjdCB3aWRlIDY0IGJpdCBjb21wYXRpYmlsaXR5PC9saT4KICA8bGk+ZHluYW1pY19wYXJzZXJfdGFnLCByZWlzc3VlIG9mIHJ1bGUuc2V0X2lkKGlkKTs8L2xpPgogIDxsaT5udW1lcm91cyBwcmltaXRpdmVzIGltcHJvdmVtZW50cyBhbmQgd29ya2Fyb3VuZHMgZm9yIHByb2JsZW1hdGljIGNvbXBpbGVyczwvbGk+CiAgPGxpPnByb3BlciBjb21wbGVtZW50ICh+KSBvZiBzaW5nbGUgY2hhciBwYXJzZXIgcHJpbWl0aXZlcyBhbmQgY2hzZXRzPC9saT4KICA8bGk+aW50dWl0aXZlIGhhbmRsaW5nIG9mIGxleGVtZV9kIDwvbGk+CiAgPGxpPndpZGVfcGhyYXNlX3NjYW5uZXJfdCB0eXBlZGVmPC9saT4KICA8bGk+ZHluYW1pYyBwYXJzZXIgaW1wcm92ZW1lbnRzIChiZXR0ZXIgc3VwcG9ydCBmb3IgbW9yZSBjb21waWxlcnMpPC9saT4KICA8bGk+Y29tcGxldGUgcmV3cml0ZSBvZiB0aGUgZmlsZV9pdGVyYXRvciAodXNpbmcgYm9vc3QuaXRlcmF0b3JfYWRhcHRlcnMpLiBTdXBwb3J0cyAKICAgIG1lbW9yeSBtYXBzIHdoZXJldmVyIGF2YWlsYWJsZTwvbGk+CiAgPGxpPm11bHRpX3Bhc3MgdXBkYXRlcyAoY29tcGF0aWJpbGl0eSB3aXRoIG1vcmUgY29tcGlsZXJzIChlLmcgVkM3KSBhbmQgbW9yZSk8L2xpPgogIDxsaT5wb3NpdGlvbl9pdGVyYXRvciBpbXByb3ZlbWVudHM8L2xpPgogIDxsaT5iZXR0ZXIgcGhvZW5peCBzdXBwb3J0IGZvciBtb3JlIGNvbXBpbGVyczwvbGk+CiAgPGxpPnBob2VuaXggbmV3XyguLi4pIGNvbnN0cnVjdDwvbGk+CiAgPGxpPm5ldyBsYXp5X3AgcGFyc2VyPC9saT4KICA8bGk+dXRpbGl0eS5kaXN0aW5jdCBwYXJzZXIgKHVuZG9jdW1lbnRlZCk8L2xpPgogIDxsaT5jaHNldCBvcGVyYXRvcnMgaW1wcm92ZW1lbnRzIDwvbGk+CiAgPGxpPmNvbmZpeF9wIHN0cmVhbWxpbmluZyBhbmQgaW1wcm92ZW1lbnRzPC9saT4KICA8bGk+bnVtZXJvdXMgQm9vc3QgaW50ZWdyYXRpb24gaW1wcm92ZW1lbnRzPC9saT4KPC91bD4KPGgyPkJ1ZyBmaXhlcyAoMS43LjAgYW5kIDEuNi4wKTwvaDI+Cjx1bD4KICA8bGk+IEZpeGVkLiBVc2luZyBNU1ZDKys2IChTUDUpLCBjYWxsaW5nIHRoZSBhc3NpZ24gYWN0aW9uIHdpdGggYSBzdHJpbmcgdmFsdWUgCiAgICBvbiBwYXJzZXJzIHVzaW5nIHRoZSBmaWxlX2l0ZXJhdG9yIHdpbGwgbm90IHdvcmsuIDwvbGk+CiAgPGxpPiBGaXhlZDogdXNpbmcgYXNzaWduIHNlbWFudGljIGFjdGlvbiBpbiBhIGdyYW1tYXIgd2l0aCBhIG11bHRpX3Bhc3MgaXRlcmF0b3IgCiAgICBhZGFwdG9yIGFwcGxpZWQgdG8gYW4gc3RkOjppc3RyZWFtX2l0ZXJhdG9yIHJlc3VsdGVkIGluIGEgZmFpbHVyZSB0byBjb21waWxlIAogICAgdW5kZXIgbXN2YyA3LjAuIDwvbGk+CiAgPGxpPiBGaXhlZDogVGhlcmUgaXMgYSBidWcgaW4gdGhlICZxdW90O3JhbmdlX3J1biZsdDtDaGFyVCZndDs6OnNldCAocmFuZ2UmbHQ7Q2hhclQmZ3Q7IAogICAgY29uc3QmYW1wOyByKSZxdW90OyBmdW5jdGlvbiBpbiB0aGUgJnF1b3Q7Ym9vc3Rcc3Bpcml0XHV0aWxpdHlcaW1wbFxjaHNldFxyYW5nZV9ydW4uaXBwJnF1b3Q7LiAKICA8L2xpPgogIDxsaT4gRml4ZWQ6IGhhbmRsaW5nIG9mIHRyYWlsaW5nIHdoaXRlc3BhY2UgYnVnIChhc3RfcGFyc2UvcHRfcGFyc2UgcmVsYXRlZCk8L2xpPgogIDxsaT4gRml4ZWQ6IGNvbW1lbnRfcCBhbmQgZW5kIG9mIGRhdGEgYnVnPC9saT4KICA8bGk+IEZpeGVkOiA8YSBocmVmPSJodHRwOi8vYXJ0aWNsZS5nbWFuZS5vcmcvZ21hbmUuY29tcC5wYXJzZXJzLnNwaXJpdC5nZW5lcmFsLzQwMjkiPk1vc3QgCiAgICB0cmFpbGluZyBzcGFjZSBidWc8L2E+OjwvbGk+CiAgPGxpPiBGaXhlZDo8YnI+CiAgICBjaHNldCZsdDsmZ3Q7OjpvcGVyYXRvcn4ocmFuZ2UmbHQ7Jmd0OykgYnVnPGJyPgogICAgb3BlcmF0b3ImYW1wOyhjaHNldCZsdDsmZ3Q7LCByYW5nZSZsdDsmZ3Q7KSBidWc8YnI+CiAgICBvcGVyYXRvciZhbXA7KHJhbmdlJmx0OyZndDssIGNoc2V0Jmx0OyZndDspIGJ1ZzwvbGk+CiAgPGxpPiBGaXhlZDogPGEgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC9tYWlsYXJjaGl2ZS9mb3J1bS5waHA/dGhyZWFkX2lkPTIwMDg1MTAmZm9ydW1faWQ9MjU5MDEiPmltcGw6OmRldGFjaF9jbGVhciAKICAgIGJ1ZzwvYT48L2xpPgogIDxsaT4gRml4ZWQ6IDxhIGhyZWY9Imh0dHA6Ly9hcnRpY2xlLmdtYW5lLm9yZy9nbWFuZS5jb21wLnBhcnNlcnMuc3Bpcml0LmdlbmVyYWwvMzY3OCI+bWlzbWF0Y2ggCiAgICBjbG9zdXJlIHJldHVybiB0eXBlIGJ1ZzwvYT48L2xpPgogIDxsaT4gRml4ZWQ6IDxhIGhyZWY9Imh0dHA6Ly9zZi5uZXQvbWFpbGFyY2hpdmUvZm9ydW0ucGhwP3RocmVhZF9pZD0xOTYzMTU3JmZvcnVtX2lkPTE1OTUiPmFjY2Vzc19ub2RlX2RbXTwvYT4gCiAgICBhbmQgPGEgaHJlZj0iaHR0cDovL3NmLm5ldC9tYWlsYXJjaGl2ZS9mb3J1bS5waHA/dGhyZWFkX2lkPTE5NjYyMjQmZm9ydW1faWQ9MTU5NSI+YWNjZXNzX21hdGNoX2RbXTwvYT4gCiAgICBpdGVyYXRvciBidWdzPC9saT4KICA8bGk+IEZpeGVkIGEgYnVnIHJlZ2FyZGluZyB0aHJlYWRzYWZldHkgb2YgUGhvZW5peC9TcGlyaXQgY2xvc3VyZXMuPC9saT4KICA8bGk+IEFkZGVkIG1pc3NpbmcgaW5jbHVkZSBmaWxlcyB0byBtaW5pYm9vc3Q8L2xpPgo8L3VsPgo8cD4gPGZvbnQgc2l6ZT0iMiIgY29sb3I9IiM2NjY2NjYiPkNvcHlyaWdodCAmY29weTsgMTk5OC0yMDA1IEpvZWwgZGUgR3V6bWFuLCBIYXJ0bXV0IEthaXNlcjwvZm9udD48YnI+Cjxmb250IHNpemU9IjIiPjxmb250IGNvbG9yPSIjNjY2NjY2Ij5Vc2UsIG1vZGlmaWNhdGlvbiBhbmQgZGlzdHJpYnV0aW9uIGlzIHN1YmplY3QgdG8gdGhlIEJvb3N0IFNvZnR3YXJlIExpY2Vuc2UsIFZlcnNpb24gMS4wLiAoU2VlIGFjY29tcGFueWluZyBmaWxlIExJQ0VOU0VfMV8wLnR4dCBvciBjb3B5IGF0IGh0dHA6Ly93d3cuYm9vc3Qub3JnL0xJQ0VOU0VfMV8wLnR4dCkgPC9mb250PiA8L2ZvbnQ+PC9wPgo8cD4mbmJzcDs8L3A+Cgo8L2JvZHk+CjwvaHRtbD4K