PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iSVNPLUxhdGluLTEiPz4KPCFET0NUWVBFIGxpYnJhcnkgUFVCTElDICItLy9Cb29zdC8vRFREIEJvb3N0Qm9vayBYTUwgVjEuMC8vRU4iCiAgImh0dHA6Ly93d3cuYm9vc3Qub3JnL3Rvb2xzL2Jvb3N0Ym9vay9kdGQvYm9vc3Rib29rLmR0ZCI+CjxsaWJyYXJ5IG5hbWU9IkxhbWJkYSIgZGlybmFtZT0ibGFtYmRhIiBpZD0ibGFtYmRhIiAKICAgICAgICAgbGFzdC1yZXZpc2lvbj0iJERhdGU6IDIwMDktMDYtMTMgMTc6MTg6MTAgLTA0MDAgKFNhdCwgMTMgSnVuIDIwMDkpICQiIAogICAgICAgICB4bWxuczp4aT0iaHR0cDovL3d3dy53My5vcmcvMjAwMS9YSW5jbHVkZSI+CjxsaWJyYXJ5aW5mbz4KICA8YXV0aG9yPgogICAgPGZpcnN0bmFtZT5KYWFra288L2ZpcnN0bmFtZT4KICAgIDxzdXJuYW1lPkrkcnZpPC9zdXJuYW1lPgogICAgIDxlbWFpbD5qYXJ2aSBhdCBjcyB0YW11IGVkdTwvZW1haWw+CiAgPC9hdXRob3I+CgogIDxjb3B5cmlnaHQ+CiAgICA8eWVhcj4xOTk5PC95ZWFyPgogICAgPHllYXI+MjAwMDwveWVhcj4KICAgIDx5ZWFyPjIwMDE8L3llYXI+CiAgICA8eWVhcj4yMDAyPC95ZWFyPgogICAgPHllYXI+MjAwMzwveWVhcj4KICAgIDx5ZWFyPjIwMDQ8L3llYXI+CiAgICA8aG9sZGVyPkphYWtrbyBK5HJ2aTwvaG9sZGVyPgogICAgPGhvbGRlcj5HYXJ5IFBvd2VsbDwvaG9sZGVyPgogIDwvY29weXJpZ2h0PgoKICA8bGVnYWxub3RpY2U+CiAgICA8cGFyYT5Vc2UsIG1vZGlmaWNhdGlvbiBhbmQgZGlzdHJpYnV0aW9uIGlzIHN1YmplY3QgdG8gdGhlIEJvb3N0CiAgICBTb2Z0d2FyZSBMaWNlbnNlLCBWZXJzaW9uIDEuMC4gKFNlZSBhY2NvbXBhbnlpbmcgZmlsZQogICAgPGZpbGVuYW1lPkxJQ0VOU0VfMV8wLnR4dDwvZmlsZW5hbWU+IG9yIGNvcHkgYXQgPHVsaW5rCiAgICB1cmw9Imh0dHA6Ly93d3cuYm9vc3Qub3JnL0xJQ0VOU0VfMV8wLnR4dCI+aHR0cDovL3d3dy5ib29zdC5vcmcvTElDRU5TRV8xXzAudHh0PC91bGluaz4pPC9wYXJhPgogIDwvbGVnYWxub3RpY2U+CgogIDxsaWJyYXJ5cHVycG9zZT5EZWZpbmUgc21hbGwgdW5uYW1lZCBmdW5jdGlvbiBvYmplY3RzIGF0IHRoZSBhY3R1YWwgY2FsbCBzaXRlLCBhbmQgbW9yZTwvbGlicmFyeXB1cnBvc2U+CiAgPGxpYnJhcnljYXRlZ29yeSBuYW1lPSJjYXRlZ29yeTpoaWdoZXItb3JkZXIiLz4KPC9saWJyYXJ5aW5mbz4KCjx0aXRsZT5Cb29zdC5MYW1iZGE8L3RpdGxlPgoKICA8IS0tICAtLT4KCiAgPHNlY3Rpb24gaWQ9ImludHJvZHVjdGlvbiI+CgogICAgPHRpdGxlPkluIGEgbnV0c2hlbGw8L3RpdGxlPgoKICAgIDxwYXJhPgoKICAgICAgVGhlIEJvb3N0IExhbWJkYSBMaWJyYXJ5IChCTEwgaW4gdGhlIHNlcXVlbCkgaXMgYSBDKysgdGVtcGxhdGUKICAgICAgbGlicmFyeSwgd2hpY2ggaW1wbGVtZW50cyBhIGZvcm0gb2YgPGVtcGhhc2lzPmxhbWJkYSBhYnN0cmFjdGlvbnM8L2VtcGhhc2lzPiBmb3IgQysrLgpUaGUgdGVybSBvcmlnaW5hdGVzIGZyb20gZnVuY3Rpb25hbCBwcm9ncmFtbWluZyBhbmQgbGFtYmRhIGNhbGN1bHVzLCB3aGVyZSBhIGxhbWJkYSBhYnN0cmFjdGlvbiBkZWZpbmVzIGFuIHVubmFtZWQgZnVuY3Rpb24uCiAgICAgIFRoZSBwcmltYXJ5IG1vdGl2YXRpb24gZm9yIHRoZSBCTEwgaXMgdG8gcHJvdmlkZSBmbGV4aWJsZSBhbmQKICAgICAgY29udmVuaWVudCBtZWFucyB0byBkZWZpbmUgdW5uYW1lZCBmdW5jdGlvbiBvYmplY3RzIGZvciBTVEwgYWxnb3JpdGhtcy4KSW4gZXhwbGFpbmluZyB3aGF0IHRoZSBsaWJyYXJ5IGlzIGFib3V0LCBhIGxpbmUgb2YgY29kZSBzYXlzIG1vcmUgdGhhbiBhIHRob3VzYW5kIHdvcmRzOyB0aGUKICAgICAgZm9sbG93aW5nIGxpbmUgb3V0cHV0cyB0aGUgZWxlbWVudHMgb2Ygc29tZSBTVEwgY29udGFpbmVyCiAgICAgIDxsaXRlcmFsPmE8L2xpdGVyYWw+IHNlcGFyYXRlZCBieSBzcGFjZXM6CgogICAgICA8cHJvZ3JhbWxpc3Rpbmc+PCFbQ0RBVEFbZm9yX2VhY2goYS5iZWdpbigpLCBhLmVuZCgpLCBzdGQ6OmNvdXQgPDwgXzEgPDwgJyAnKTtdXT48L3Byb2dyYW1saXN0aW5nPgoKICAgICAgVGhlIGV4cHJlc3Npb24gPGxpdGVyYWw+PCFbQ0RBVEFbc3RkOjpjb3V0IDw8IF8xIDw8ICcgJ11dPjwvbGl0ZXJhbD4gZGVmaW5lcyBhIHVuYXJ5IGZ1bmN0aW9uIG9iamVjdC4gCiAgICAgIFRoZSB2YXJpYWJsZSA8bGl0ZXJhbD5fMTwvbGl0ZXJhbD4gaXMgdGhlIHBhcmFtZXRlciBvZiB0aGlzIGZ1bmN0aW9uLCBhIDxlbXBoYXNpcz5wbGFjZWhvbGRlcjwvZW1waGFzaXM+IGZvciB0aGUgYWN0dWFsIGFyZ3VtZW50LiAKICAgICAgV2l0aGluIGVhY2ggaXRlcmF0aW9uIG9mIDxsaXRlcmFsPmZvcl9lYWNoPC9saXRlcmFsPiwgdGhlIGZ1bmN0aW9uIGlzCiAgICAgIGNhbGxlZCB3aXRoIGFuIGVsZW1lbnQgb2YgPGxpdGVyYWw+YTwvbGl0ZXJhbD4gYXMgdGhlIGFjdHVhbCBhcmd1bWVudC4KICAgICAgVGhpcyBhY3R1YWwgYXJndW1lbnQgaXMgc3Vic3RpdHV0ZWQgZm9yIHRoZSBwbGFjZWhvbGRlciwgYW5kIHRoZSA8cXVvdGU+Ym9keTwvcXVvdGU+IG9mIHRoZSBmdW5jdGlvbiBpcyBldmFsdWF0ZWQuCiAgICA8L3BhcmE+CgogICAgPHBhcmE+VGhlIGVzc2VuY2Ugb2YgQkxMIGlzIGxldHRpbmcgeW91IGRlZmluZSBzbWFsbCB1bm5hbWVkIGZ1bmN0aW9uIG9iamVjdHMsIHN1Y2ggYXMgdGhlIG9uZSBhYm92ZSwgZGlyZWN0bHkgb24gdGhlIGNhbGwgc2l0ZSBvZiBhbiBTVEwgYWxnb3JpdGhtLgogICAgPC9wYXJhPgogIDwvc2VjdGlvbj4KCiAgPHNlY3Rpb24gaWQ9ImxhbWJkYS5nZXR0aW5nX3N0YXJ0ZWQiPgogICAgPHRpdGxlPkdldHRpbmcgU3RhcnRlZDwvdGl0bGU+CgogICAgPHNlY3Rpb24+CiAgICAgIDx0aXRsZT5JbnN0YWxsaW5nIHRoZSBsaWJyYXJ5PC90aXRsZT4KICAgICAgCgogICAgICA8cGFyYT4KCVRoZSBsaWJyYXJ5IGNvbnNpc3RzIG9mIGluY2x1ZGUgZmlsZXMgb25seSwgaGVuY2UgdGhlcmUgaXMgbm8KCWluc3RhbGxhdGlvbiBwcm9jZWR1cmUuIFRoZSA8bGl0ZXJhbD5ib29zdDwvbGl0ZXJhbD4gaW5jbHVkZSBkaXJlY3RvcnkKCW11c3QgYmUgb24gdGhlIGluY2x1ZGUgcGF0aC4KCVRoZXJlIGFyZSBhIG51bWJlciBvZiBpbmNsdWRlIGZpbGVzIHRoYXQgZ2l2ZSBkaWZmZXJlbnQgZnVuY3Rpb25hbGl0eToKCgk8IS0tIFRPRE86IHRhcmtpc3RhIHZpZWzkIHJpaXBwdXZ1dWRldC0tPgoJPGl0ZW1pemVkbGlzdD4KCgkgIDxsaXN0aXRlbT48cGFyYT4KCSAgICAgIDxmaWxlbmFtZT5sYW1iZGEvbGFtYmRhLmhwcDwvZmlsZW5hbWU+IGRlZmluZXMgbGFtYmRhIGV4cHJlc3Npb25zIGZvciBkaWZmZXJlbnQgQysrCgkgICAgICBvcGVyYXRvcnMsIHNlZSA8eHJlZiBsaW5rZW5kPSJsYW1iZGEub3BlcmF0b3JfZXhwcmVzc2lvbnMiLz4uCgkgICAgPC9wYXJhPjwvbGlzdGl0ZW0+CgoJICA8bGlzdGl0ZW0+PHBhcmE+CgkgICAgICA8ZmlsZW5hbWU+bGFtYmRhL2JpbmQuaHBwPC9maWxlbmFtZT4gZGVmaW5lcyA8bGl0ZXJhbD5iaW5kPC9saXRlcmFsPiBmdW5jdGlvbnMgZm9yIHVwIHRvIDkgYXJndW1lbnRzLCBzZWUgPHhyZWYgbGlua2VuZD0ibGFtYmRhLmJpbmRfZXhwcmVzc2lvbnMiLz4uPC9wYXJhPjwvbGlzdGl0ZW0+CgoKCSAgPGxpc3RpdGVtPjxwYXJhPgoJICAgICAgPGZpbGVuYW1lPmxhbWJkYS9pZi5ocHA8L2ZpbGVuYW1lPiBkZWZpbmVzIGxhbWJkYSBmdW5jdGlvbiBlcXVpdmFsZW50cyBmb3IgaWYgc3RhdGVtZW50cyBhbmQgdGhlIGNvbmRpdGlvbmFsIG9wZXJhdG9yLCBzZWUgPHhyZWYgbGlua2VuZD0ibGFtYmRhLmxhbWJkYV9leHByZXNzaW9uc19mb3JfY29udHJvbF9zdHJ1Y3R1cmVzIi8+IChpbmNsdWRlcyA8ZmlsZW5hbWU+bGFtYmRhLmhwcDwvZmlsZW5hbWU+KS4KCSAgICA8L3BhcmE+PC9saXN0aXRlbT4KCgkgIDxsaXN0aXRlbT48cGFyYT4KCSAgICAgIDxmaWxlbmFtZT5sYW1iZGEvbG9vcHMuaHBwPC9maWxlbmFtZT4gZGVmaW5lcyBsYW1iZGEgZnVuY3Rpb24gZXF1aXZhbGVudCBmb3IgbG9vcGluZyBjb25zdHJ1Y3RzLCBzZWUgPHhyZWYgbGlua2VuZD0ibGFtYmRhLmxhbWJkYV9leHByZXNzaW9uc19mb3JfY29udHJvbF9zdHJ1Y3R1cmVzIi8+LgoJICAgIDwvcGFyYT48L2xpc3RpdGVtPgoKCSAgPGxpc3RpdGVtPjxwYXJhPgoJICAgICAgPGZpbGVuYW1lPmxhbWJkYS9zd2l0Y2guaHBwPC9maWxlbmFtZT4gZGVmaW5lcyBsYW1iZGEgZnVuY3Rpb24gZXF1aXZhbGVudCBmb3IgdGhlIHN3aXRjaCBzdGF0ZW1lbnQsIHNlZSA8eHJlZiBsaW5rZW5kPSJsYW1iZGEubGFtYmRhX2V4cHJlc3Npb25zX2Zvcl9jb250cm9sX3N0cnVjdHVyZXMiLz4uCgkgICAgPC9wYXJhPjwvbGlzdGl0ZW0+CgoJICA8bGlzdGl0ZW0+PHBhcmE+CgkgICAgICA8ZmlsZW5hbWU+bGFtYmRhL2NvbnN0cnVjdC5ocHA8L2ZpbGVuYW1lPiBwcm92aWRlcyB0b29scyBmb3Igd3JpdGluZyBsYW1iZGEgZXhwcmVzc2lvbnMgd2l0aCBjb25zdHJ1Y3RvciwgZGVzdHJ1Y3RvciwgbmV3IGFuZCBkZWxldGUgaW52b2NhdGlvbnMsIHNlZSA8eHJlZiBsaW5rZW5kPSJsYW1iZGEuY29uc3RydWN0aW9uX2FuZF9kZXN0cnVjdGlvbiIvPiAoaW5jbHVkZXMgPGZpbGVuYW1lPmxhbWJkYS5ocHA8L2ZpbGVuYW1lPikuCgkgICAgPC9wYXJhPjwvbGlzdGl0ZW0+CgoJICA8bGlzdGl0ZW0+PHBhcmE+CgkgICAgICA8ZmlsZW5hbWU+bGFtYmRhL2Nhc3RzLmhwcDwvZmlsZW5hbWU+IHByb3ZpZGVzIGxhbWJkYSB2ZXJzaW9ucyBvZiBkaWZmZXJlbnQgY2FzdHMsIGFzIHdlbGwgYXMgPGxpdGVyYWw+c2l6ZW9mPC9saXRlcmFsPiBhbmQgPGxpdGVyYWw+dHlwZWlkPC9saXRlcmFsPiwgc2VlIDx4cmVmIGxpbmtlbmQ9ImxhbWJkYS5jYXN0X2V4cHJlc3Npb25zIi8+LgoJICAgIDwvcGFyYT48L2xpc3RpdGVtPgoKCSAgPGxpc3RpdGVtPjxwYXJhPgoJICAgICAgPGZpbGVuYW1lPmxhbWJkYS9leGNlcHRpb25zLmhwcDwvZmlsZW5hbWU+IGdpdmVzIHRvb2xzIGZvciB0aHJvd2luZyBhbmQgY2F0Y2hpbmcKCSAgICAgIGV4Y2VwdGlvbnMgd2l0aGluIGxhbWJkYSBmdW5jdGlvbnMsIDx4cmVmIGxpbmtlbmQ9ImxhbWJkYS5leGNlcHRpb25zIi8+IChpbmNsdWRlcwoJICAgICAgPGZpbGVuYW1lPmxhbWJkYS5ocHA8L2ZpbGVuYW1lPikuCgkgICAgPC9wYXJhPjwvbGlzdGl0ZW0+CgoJICA8bGlzdGl0ZW0+PHBhcmE+CgkgICAgICA8ZmlsZW5hbWU+bGFtYmRhL2FsZ29yaXRobS5ocHA8L2ZpbGVuYW1lPiBhbmQgPGZpbGVuYW1lPmxhbWJkYS9udW1lcmljLmhwcDwvZmlsZW5hbWU+IChjZi4gc3RhbmRhcmQgPGZpbGVuYW1lPmFsZ29ydGlobTwvZmlsZW5hbWU+IGFuZCA8ZmlsZW5hbWU+bnVtZXJpYzwvZmlsZW5hbWU+IGhlYWRlcnMpIGFsbG93IG5lc3RlZCBTVEwgYWxnb3JpdGhtIGludm9jYXRpb25zLCBzZWUgPHhyZWYgbGlua2VuZD0ibGFtYmRhLm5lc3RlZF9zdGxfYWxnb3JpdGhtcyIvPi4KCSAgICA8L3BhcmE+PC9saXN0aXRlbT4KCgk8L2l0ZW1pemVkbGlzdD4KCglBbnkgb3RoZXIgaGVhZGVyIGZpbGVzIGluIHRoZSBwYWNrYWdlIGFyZSBmb3IgaW50ZXJuYWwgdXNlLgoJQWRkaXRpb25hbGx5LCB0aGUgbGlicmFyeSBkZXBlbmRzIG9uIHR3byBvdGhlciBCb29zdCBMaWJyYXJpZXMsIHRoZQoJPGVtcGhhc2lzPlR1cGxlPC9lbXBoYXNpcz4gPHhyZWYgbGlua2VuZD0iY2l0OmJvb3N0Ojp0dXBsZSIvPiBhbmQgdGhlIDxlbXBoYXNpcz50eXBlX3RyYWl0czwvZW1waGFzaXM+IDx4cmVmIGxpbmtlbmQ9ImNpdDpib29zdDo6dHlwZV90cmFpdHMiLz4gbGlicmFyaWVzLCBhbmQgb24gdGhlIDxmaWxlbmFtZT5ib29zdC9yZWYuaHBwPC9maWxlbmFtZT4gaGVhZGVyLgogICAgICA8L3BhcmE+CgogICAgICA8cGFyYT4KCUFsbCBkZWZpbml0aW9ucyBhcmUgcGxhY2VkIGluIHRoZSBuYW1lc3BhY2UgPGxpdGVyYWw+Ym9vc3Q6OmxhbWJkYTwvbGl0ZXJhbD4gYW5kIGl0cyBzdWJuYW1lc3BhY2VzLgogICAgICA8L3BhcmE+CgogICAgPC9zZWN0aW9uPgoKICAgIDxzZWN0aW9uPgogICAgICA8dGl0bGU+Q29udmVudGlvbnMgdXNlZCBpbiB0aGlzIGRvY3VtZW50PC90aXRsZT4KCiAgICAgIDxwYXJhPkluIG1vc3QgY29kZSBleGFtcGxlcywgd2Ugb21pdCB0aGUgbmFtZXNwYWNlIHByZWZpeGVzIGZvciBuYW1lcyBpbiB0aGUgPGxpdGVyYWwgbW9yZWluZm89Im5vbmUiPnN0ZDwvbGl0ZXJhbD4gYW5kIDxsaXRlcmFsIG1vcmVpbmZvPSJub25lIj5ib29zdDo6bGFtYmRhPC9saXRlcmFsPiBuYW1lc3BhY2VzLgpJbXBsaWNpdCB1c2luZyBkZWNsYXJhdGlvbnMKPHByb2dyYW1saXN0aW5nPgp1c2luZyBuYW1lc3BhY2Ugc3RkOwp1c2luZyBuYW1lc3BhY2UgYm9vc3Q6OmxhbWJkYTsKPC9wcm9ncmFtbGlzdGluZz4KYXJlIGFzc3VtZWQgdG8gYmUgaW4gZWZmZWN0Lgo8L3BhcmE+IAoKICAgIDwvc2VjdGlvbj4KICA8L3NlY3Rpb24+CgogIDxzZWN0aW9uPgogICAgPHRpdGxlPkludHJvZHVjdGlvbjwvdGl0bGU+CgogICAgPHNlY3Rpb24+CiAgICAgIDx0aXRsZT5Nb3RpdmF0aW9uPC90aXRsZT4KICAgICAgPHBhcmE+VGhlIFN0YW5kYXJkIFRlbXBsYXRlIExpYnJhcnkgKFNUTCkKCTx4cmVmIHJvbGU9ImNpdGF0aW9uIiBsaW5rZW5kPSJjaXQ6c3RlcGFub3Y6OTQiLz4sIG5vdyBwYXJ0IG9mIHRoZSBDKysgU3RhbmRhcmQgTGlicmFyeSA8eHJlZiByb2xlPSJjaXRhdGlvbiIgbGlua2VuZD0iY2l0OmMrKzo5OCIvPiwgaXMgYSBnZW5lcmljIGNvbnRhaW5lciBhbmQgYWxnb3JpdGhtIGxpYnJhcnkuClR5cGljYWxseSBTVEwgYWxnb3JpdGhtcyBvcGVyYXRlIG9uIGNvbnRhaW5lciBlbGVtZW50cyB2aWEgPGVtcGhhc2lzPmZ1bmN0aW9uIG9iamVjdHM8L2VtcGhhc2lzPi4gVGhlc2UgZnVuY3Rpb24gb2JqZWN0cyBhcmUgcGFzc2VkIGFzIGFyZ3VtZW50cyB0byB0aGUgYWxnb3JpdGhtcy4KPC9wYXJhPgoKPHBhcmE+CkFueSBDKysgY29uc3RydWN0IHRoYXQgY2FuIGJlIGNhbGxlZCB3aXRoIHRoZSBmdW5jdGlvbiBjYWxsIHN5bnRheAppcyBhIGZ1bmN0aW9uIG9iamVjdC4gClRoZSBTVEwgY29udGFpbnMgcHJlZGVmaW5lZCBmdW5jdGlvbiBvYmplY3RzIGZvciBzb21lIGNvbW1vbiBjYXNlcyAoc3VjaCBhcyA8bGl0ZXJhbD5wbHVzPC9saXRlcmFsPiwgPGxpdGVyYWw+bGVzczwvbGl0ZXJhbD4gYW5kIDxsaXRlcmFsPm5vdDE8L2xpdGVyYWw+KS4gCkFzIGFuIGV4YW1wbGUsIG9uZSBwb3NzaWJsZSBpbXBsZW1lbnRhdGlvbiBmb3IgdGhlIHN0YW5kYXJkIDxsaXRlcmFsPnBsdXM8L2xpdGVyYWw+IHRlbXBsYXRlIGlzOgoKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVt0ZW1wbGF0ZSA8Y2xhc3MgVD4gCnN0cnVjdCBwbHVzIDogcHVibGljIGJpbmFyeV9mdW5jdGlvbjxULCBULCBUPiB7CiAgVCBvcGVyYXRvcigpKGNvbnN0IFQmIGksIGNvbnN0IFQmIGopIGNvbnN0IHsKICAgIHJldHVybiBpICsgajsgCiAgfQp9O11dPgo8L3Byb2dyYW1saXN0aW5nPgoKVGhlIGJhc2UgY2xhc3MgPGxpdGVyYWw+PCFbQ0RBVEFbYmluYXJ5X2Z1bmN0aW9uPFQsIFQsIFQ+XV0+PC9saXRlcmFsPiBjb250YWlucyB0eXBlZGVmcyBmb3IgdGhlIGFyZ3VtZW50IGFuZCByZXR1cm4gdHlwZXMgb2YgdGhlIGZ1bmN0aW9uIG9iamVjdCwgd2hpY2ggYXJlIG5lZWRlZCB0byBtYWtlIHRoZSBmdW5jdGlvbiBvYmplY3QgPGVtcGhhc2lzPmFkYXB0YWJsZTwvZW1waGFzaXM+Lgo8L3BhcmE+Cgo8cGFyYT4KSW4gYWRkaXRpb24gdG8gdGhlIGJhc2ljIGZ1bmN0aW9uIG9iamVjdCBjbGFzc2VzLCBzdWNoIGFzIHRoZSBvbmUgYWJvdmUsCnRoZSBTVEwgY29udGFpbnMgPGVtcGhhc2lzPmJpbmRlcjwvZW1waGFzaXM+IHRlbXBsYXRlcyBmb3IgY3JlYXRpbmcgYSB1bmFyeSBmdW5jdGlvbiBvYmplY3QgZnJvbSBhbiBhZGFwdGFibGUgYmluYXJ5IGZ1bmN0aW9uIG9iamVjdCBieSBmaXhpbmcgb25lIG9mIHRoZSBhcmd1bWVudHMgdG8gYSBjb25zdGFudCB2YWx1ZS4KRm9yIGV4YW1wbGUsIGluc3RlYWQgb2YgaGF2aW5nIHRvIGV4cGxpY2l0bHkgd3JpdGUgYSBmdW5jdGlvbiBvYmplY3QgY2xhc3MgbGlrZToKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbY2xhc3MgcGx1c18xIHsKICBpbnQgX2k7CnB1YmxpYzoKICBwbHVzXzEoY29uc3QgaW50JiBpKSA6IF9pKGkpIHt9CiAgaW50IG9wZXJhdG9yKCkoY29uc3QgaW50JiBqKSB7IHJldHVybiBfaSArIGo7IH0KfTtdXT4KPC9wcm9ncmFtbGlzdGluZz4KCnRoZSBlcXVpdmFsZW50IGZ1bmN0aW9uYWxpdHkgY2FuIGJlIGFjaGlldmVkIHdpdGggdGhlIDxsaXRlcmFsIG1vcmVpbmZvPSJub25lIj5wbHVzPC9saXRlcmFsPiB0ZW1wbGF0ZSBhbmQgb25lIG9mIHRoZSBiaW5kZXIgdGVtcGxhdGVzICg8bGl0ZXJhbCBtb3JlaW5mbz0ibm9uZSI+YmluZDFzdDwvbGl0ZXJhbD4pLgpFLmcuLCB0aGUgZm9sbG93aW5nIHR3byBleHByZXNzaW9ucyBjcmVhdGUgZnVuY3Rpb24gb2JqZWN0cyB3aXRoIGlkZW50aWNhbCBmdW5jdGlvbmFsaXRpZXM7IAp3aGVuIGludm9rZWQsIGJvdGggcmV0dXJuIHRoZSByZXN1bHQgb2YgYWRkaW5nIDxsaXRlcmFsIG1vcmVpbmZvPSJub25lIj4xPC9saXRlcmFsPiB0byB0aGUgYXJndW1lbnQgb2YgdGhlIGZ1bmN0aW9uIG9iamVjdDoKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbcGx1c18xKDEpCmJpbmQxc3QocGx1czxpbnQ+KCksIDEpXV0+CjwvcHJvZ3JhbWxpc3Rpbmc+CgpUaGUgc3ViZXhwcmVzc2lvbiA8bGl0ZXJhbD48IVtDREFUQVtwbHVzPGludD4oKV1dPjwvbGl0ZXJhbD4gaW4gdGhlIGxhdHRlciBsaW5lIGlzIGEgYmluYXJ5IGZ1bmN0aW9uIG9iamVjdCB3aGljaCBjb21wdXRlcyB0aGUgc3VtIG9mIHR3byBpbnRlZ2VycywgYW5kIDxsaXRlcmFsPmJpbmQxc3Q8L2xpdGVyYWw+IGludm9rZXMgdGhpcyBmdW5jdGlvbiBvYmplY3QgcGFydGlhbGx5IGJpbmRpbmcgdGhlIGZpcnN0IGFyZ3VtZW50IHRvIDxsaXRlcmFsPjE8L2xpdGVyYWw+LgpBcyBhbiBleGFtcGxlIG9mIHVzaW5nIHRoZSBhYm92ZSBmdW5jdGlvbiBvYmplY3QsIHRoZSBmb2xsb3dpbmcgY29kZSBhZGRzIDxsaXRlcmFsPjE8L2xpdGVyYWw+IHRvIGVhY2ggZWxlbWVudCBvZiBzb21lIGNvbnRhaW5lciA8bGl0ZXJhbD5hPC9saXRlcmFsPiBhbmQgb3V0cHV0cyB0aGUgcmVzdWx0cyBpbnRvIHRoZSBzdGFuZGFyZCBvdXRwdXQgc3RyZWFtIDxsaXRlcmFsPmNvdXQ8L2xpdGVyYWw+LgoKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVt0cmFuc2Zvcm0oYS5iZWdpbigpLCBhLmVuZCgpLCBvc3RyZWFtX2l0ZXJhdG9yPGludD4oY291dCksCiAgICAgICAgICBiaW5kMXN0KHBsdXM8aW50PigpLCAxKSk7XV0+CjwvcHJvZ3JhbWxpc3Rpbmc+Cgo8L3BhcmE+Cgo8cGFyYT4KVG8gbWFrZSB0aGUgYmluZGVyIHRlbXBsYXRlcyBtb3JlIGdlbmVyYWxseSBhcHBsaWNhYmxlLCB0aGUgU1RMIGNvbnRhaW5zIDxlbXBoYXNpcz5hZGFwdG9yczwvZW1waGFzaXM+IGZvciBtYWtpbmcgCnBvaW50ZXJzIG9yIHJlZmVyZW5jZXMgdG8gZnVuY3Rpb25zLCBhbmQgcG9pbnRlcnMgdG8gbWVtYmVyIGZ1bmN0aW9ucywgCmFkYXB0YWJsZS4KCkZpbmFsbHksIHNvbWUgU1RMIGltcGxlbWVudGF0aW9ucyBjb250YWluIGZ1bmN0aW9uIGNvbXBvc2l0aW9uIG9wZXJhdGlvbnMgYXMKZXh0ZW5zaW9ucyB0byB0aGUgc3RhbmRhcmQgPHhyZWYgbGlua2VuZD0iY2l0OnNnaTowMiIvPi4KICAgICAgPC9wYXJhPgoKPHBhcmE+CkFsbCB0aGVzZSB0b29scyBhaW0gYXQgb25lIGdvYWw6IHRvIG1ha2UgaXQgcG9zc2libGUgdG8gc3BlY2lmeSAKPGVtcGhhc2lzPnVubmFtZWQgZnVuY3Rpb25zPC9lbXBoYXNpcz4gaW4gYSBjYWxsIG9mIGFuIFNUTCBhbGdvcml0aG0sIAppbiBvdGhlciB3b3JkcywgdG8gcGFzcyBjb2RlIGZyYWdtZW50cyBhcyBhbiBhcmd1bWVudCB0byBhIGZ1bmN0aW9uLiAKCkhvd2V2ZXIsIHRoaXMgZ29hbCBpcyBhdHRhaW5lZCBvbmx5IHBhcnRpYWxseS4KVGhlIHNpbXBsZSBleGFtcGxlIGFib3ZlIHNob3dzIHRoYXQgdGhlIGRlZmluaXRpb24gb2YgdW5uYW1lZCBmdW5jdGlvbnMgCndpdGggdGhlIHN0YW5kYXJkIHRvb2xzIGlzIGN1bWJlcnNvbWUuCgpDb21wbGV4IGV4cHJlc3Npb25zIGludm9sdmluZyBmdW5jdG9ycywgYWRhcHRvcnMsIGJpbmRlcnMgYW5kIApmdW5jdGlvbiBjb21wb3NpdGlvbiBvcGVyYXRpb25zIHRlbmQgdG8gYmUgZGlmZmljdWx0IHRvIGNvbXByZWhlbmQuCgpJbiBhZGRpdGlvbiB0byB0aGlzLCB0aGVyZSBhcmUgc2lnbmlmaWNhbnQgcmVzdHJpY3Rpb25zIGluIGFwcGx5aW5nIAp0aGUgc3RhbmRhcmQgdG9vbHMuIEUuZy4gdGhlIHN0YW5kYXJkIGJpbmRlcnMgYWxsb3cgb25seSBvbmUgYXJndW1lbnQgCm9mIGEgYmluYXJ5IGZ1bmN0aW9uIHRvIGJlIGJvdW5kOyB0aGVyZSBhcmUgbm8gYmluZGVycyBmb3IgCjMtYXJ5LCA0LWFyeSBldGMuIGZ1bmN0aW9ucy4gCjwvcGFyYT4KCjxwYXJhPgpUaGUgQm9vc3QgTGFtYmRhIExpYnJhcnkgcHJvdmlkZXMgc29sdXRpb25zIGZvciB0aGUgcHJvYmxlbXMgZGVzY3JpYmVkIGFib3ZlOgoKPGl0ZW1pemVkbGlzdD4KPGxpc3RpdGVtPgo8cGFyYT4KVW5uYW1lZCBmdW5jdGlvbnMgY2FuIGJlIGNyZWF0ZWQgZWFzaWx5IHdpdGggYW4gaW50dWl0aXZlIHN5bnRheC4gCgpUaGUgYWJvdmUgZXhhbXBsZSBjYW4gYmUgd3JpdHRlbiBhczoKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbdHJhbnNmb3JtKGEuYmVnaW4oKSwgYS5lbmQoKSwgb3N0cmVhbV9pdGVyYXRvcjxpbnQ+KGNvdXQpLCAKICAgICAgICAgIDEgKyBfMSk7XV0+CjwvcHJvZ3JhbWxpc3Rpbmc+CgpvciBldmVuIG1vcmUgaW50dWl0aXZlbHk6Cgo8cHJvZ3JhbWxpc3Rpbmc+CjwhW0NEQVRBW2Zvcl9lYWNoKGEuYmVnaW4oKSwgYS5lbmQoKSwgY291dCA8PCAoMSArIF8xKSk7XV0+CjwvcHJvZ3JhbWxpc3Rpbmc+CjwvcGFyYT4KCjwvbGlzdGl0ZW0+Cgo8bGlzdGl0ZW0+CjxwYXJhPgpNb3N0IG9mIHRoZSByZXN0cmljdGlvbnMgaW4gYXJndW1lbnQgYmluZGluZyBhcmUgcmVtb3ZlZCwgCmFyYml0cmFyeSBhcmd1bWVudHMgb2YgcHJhY3RpY2FsbHkgYW55IEMrKyBmdW5jdGlvbiBjYW4gYmUgYm91bmQuCjwvcGFyYT4KPC9saXN0aXRlbT4KCjxsaXN0aXRlbT4KPHBhcmE+ClNlcGFyYXRlIGZ1bmN0aW9uIGNvbXBvc2l0aW9uIG9wZXJhdGlvbnMgYXJlIG5vdCBuZWVkZWQsIAphcyBmdW5jdGlvbiBjb21wb3NpdGlvbiBpcyBzdXBwb3J0ZWQgaW1wbGljaXRseS4KCjwvcGFyYT4KPC9saXN0aXRlbT4KCjwvaXRlbWl6ZWRsaXN0PgoKPC9wYXJhPgoKPC9zZWN0aW9uPgoKCgo8c2VjdGlvbj4KICAgICAgPHRpdGxlPkludHJvZHVjdGlvbiB0byBsYW1iZGEgZXhwcmVzc2lvbnM8L3RpdGxlPgoKICAgICAgPHBhcmE+CglMYW1iZGEgZXhwcmVzc2lvbiBhcmUgY29tbW9uIGluIGZ1bmN0aW9uYWwgcHJvZ3JhbW1pbmcgbGFuZ3VhZ2VzLiAKCVRoZWlyIHN5bnRheCB2YXJpZXMgYmV0d2VlbiBsYW5ndWFnZXMgKGFuZCBiZXR3ZWVuIGRpZmZlcmVudCBmb3JtcyBvZiBsYW1iZGEgY2FsY3VsdXMpLCBidXQgdGhlIGJhc2ljIGZvcm0gb2YgYSBsYW1iZGEgZXhwcmVzc2lvbnMgaXM6CgoKPHByb2dyYW1saXN0aW5nPgpsYW1iZGEgeDxzdWJzY3JpcHQ+MTwvc3Vic2NyaXB0PiAuLi4geDxzdWJzY3JpcHQ+bjwvc3Vic2NyaXB0Pi5lCjwvcHJvZ3JhbWxpc3Rpbmc+Cgk8IS0tICRcbGFtYmRhIHhfMSBcY2RvdHMgeF9uIC4gZSQgLS0+CgoJQSBsYW1iZGEgZXhwcmVzc2lvbiBkZWZpbmVzIGFuIHVubmFtZWQgZnVuY3Rpb24gYW5kIGNvbnNpc3RzIG9mOgoJPGl0ZW1pemVkbGlzdD4KCSAgPGxpc3RpdGVtPgoJICAgIDxwYXJhPgoJICAgICAgdGhlIHBhcmFtZXRlcnMgb2YgdGhpcyBmdW5jdGlvbjogPGxpdGVyYWw+eDxzdWJzY3JpcHQ+MTwvc3Vic2NyaXB0PiAuLi4geDxzdWJzY3JpcHQ+bjwvc3Vic2NyaXB0PjwvbGl0ZXJhbD4uCgkgICAgICA8IS0tJHhfMSBcY2RvdHMgeF9uJC0tPgoJICAgIDwvcGFyYT4KCSAgPC9saXN0aXRlbT4KCSAgPGxpc3RpdGVtPgoJICAgIDxwYXJhPnRoZSBleHByZXNzaW9uIGUgd2hpY2ggY29tcHV0ZXMgdGhlIHZhbHVlIG9mIHRoZSBmdW5jdGlvbiBpbiB0ZXJtcyBvZiB0aGUgcGFyYW1ldGVycyA8bGl0ZXJhbD54PHN1YnNjcmlwdD4xPC9zdWJzY3JpcHQ+IC4uLiB4PHN1YnNjcmlwdD5uPC9zdWJzY3JpcHQ+PC9saXRlcmFsPi4KCSAgICA8L3BhcmE+CgkgIDwvbGlzdGl0ZW0+Cgk8L2l0ZW1pemVkbGlzdD4KCglBIHNpbXBsZSBleGFtcGxlIG9mIGEgbGFtYmRhIGV4cHJlc3Npb24gaXMgCjxwcm9ncmFtbGlzdGluZz4KbGFtYmRhIHggeS54K3kKPC9wcm9ncmFtbGlzdGluZz4KQXBwbHlpbmcgdGhlIGxhbWJkYSBmdW5jdGlvbiBtZWFucyBzdWJzdGl0dXRpbmcgdGhlIGZvcm1hbCBwYXJhbWV0ZXJzIHdpdGggdGhlIGFjdHVhbCBhcmd1bWVudHM6Cjxwcm9ncmFtbGlzdGluZz4KKGxhbWJkYSB4IHkueCt5KSAyIDMgPSAyICsgMyA9IDUgCjwvcHJvZ3JhbWxpc3Rpbmc+CgoKICAgICAgPC9wYXJhPgoKPHBhcmE+CkluIHRoZSBDKysgdmVyc2lvbiBvZiBsYW1iZGEgZXhwcmVzc2lvbnMgdGhlIDxsaXRlcmFsPmxhbWJkYSB4PHN1YnNjcmlwdD4xPC9zdWJzY3JpcHQ+IC4uLiB4PHN1YnNjcmlwdD5uPC9zdWJzY3JpcHQ+PC9saXRlcmFsPiBwYXJ0IGlzIG1pc3NpbmcgYW5kIHRoZSBmb3JtYWwgcGFyYW1ldGVycyBoYXZlIHByZWRlZmluZWQgbmFtZXMuCkluIHRoZSBjdXJyZW50IHZlcnNpb24gb2YgdGhlIGxpYnJhcnksIAp0aGVyZSBhcmUgdGhyZWUgc3VjaCBwcmVkZWZpbmVkIGZvcm1hbCBwYXJhbWV0ZXJzLCAKY2FsbGVkIDxlbXBoYXNpcz5wbGFjZWhvbGRlcnM8L2VtcGhhc2lzPjogCjxsaXRlcmFsPl8xPC9saXRlcmFsPiwgPGxpdGVyYWw+XzI8L2xpdGVyYWw+IGFuZCA8bGl0ZXJhbD5fMzwvbGl0ZXJhbD4uIApUaGV5IHJlZmVyIHRvIHRoZSBmaXJzdCwgc2Vjb25kIGFuZCB0aGlyZCBhcmd1bWVudCBvZiB0aGUgZnVuY3Rpb24gZGVmaW5lZCAKYnkgdGhlIGxhbWJkYSBleHByZXNzaW9uLgoJCkZvciBleGFtcGxlLCB0aGUgQysrIHZlcnNpb24gb2YgdGhlIGRlZmluaXRpb24KPHByb2dyYW1saXN0aW5nPmxhbWJkYSB4IHkueCt5PC9wcm9ncmFtbGlzdGluZz4KaXMgCjxwcm9ncmFtbGlzdGluZz5fMSArIF8yPC9wcm9ncmFtbGlzdGluZz4KPC9wYXJhPgoKICAgICAgPHBhcmE+CkhlbmNlLCB0aGVyZSBpcyBubyBzeW50YWN0aWMga2V5d29yZCBmb3IgQysrIGxhbWJkYSBleHByZXNzaW9ucy4gCglUaGUgdXNlIG9mIGEgcGxhY2Vob2xkZXIgYXMgYW4gb3BlcmFuZCBpbXBsaWVzIHRoYXQgdGhlIG9wZXJhdG9yIGludm9jYXRpb24gaXMgYSBsYW1iZGEgZXhwcmVzc2lvbi4KCUhvd2V2ZXIsIHRoaXMgaXMgdHJ1ZSBvbmx5IGZvciBvcGVyYXRvciBpbnZvY2F0aW9ucy4KCUxhbWJkYSBleHByZXNzaW9ucyBjb250YWluaW5nIGZ1bmN0aW9uIGNhbGxzLCBjb250cm9sIHN0cnVjdHVyZXMsIGNhc3RzIGV0Yy4gcmVxdWlyZSBzcGVjaWFsIHN5bnRhY3RpYyBjb25zdHJ1Y3RzLiAKCU1vc3QgaW1wb3J0YW50bHksIGZ1bmN0aW9uIGNhbGxzIG5lZWQgdG8gYmUgd3JhcHBlZCBpbnNpZGUgYSA8bGl0ZXJhbD5iaW5kPC9saXRlcmFsPiBmdW5jdGlvbi4gCgoJQXMgYW4gZXhhbXBsZSwgY29uc2lkZXIgdGhlIGxhbWJkYSBleHByZXNzaW9uOgoKCTxwcm9ncmFtbGlzdGluZz5sYW1iZGEgeCB5LmZvbyh4LHkpPC9wcm9ncmFtbGlzdGluZz4KCglSYXRoZXIgdGhhbiA8bGl0ZXJhbD5mb28oXzEsIF8yKTwvbGl0ZXJhbD4sIHRoZSBDKysgY291bnRlcnBhcnQgZm9yIHRoaXMgZXhwcmVzc2lvbiBpczoKCgk8cHJvZ3JhbWxpc3Rpbmc+YmluZChmb28sIF8xLCBfMik8L3Byb2dyYW1saXN0aW5nPgoKCVdlIHJlZmVyIHRvIHRoaXMgdHlwZSBvZiBDKysgbGFtYmRhIGV4cHJlc3Npb25zIGFzIDxlbXBoYXNpcz5iaW5kIGV4cHJlc3Npb25zPC9lbXBoYXNpcz4uIAogICAgICA8L3BhcmE+CgogICAgICA8cGFyYT5BIGxhbWJkYSBleHByZXNzaW9uIGRlZmluZXMgYSBDKysgZnVuY3Rpb24gb2JqZWN0LCBoZW5jZSBmdW5jdGlvbiBhcHBsaWNhdGlvbiBzeW50YXggaXMgbGlrZSBjYWxsaW5nIGFueSBvdGhlciBmdW5jdGlvbiBvYmplY3QsIGZvciBpbnN0YW5jZTogPGxpdGVyYWw+KF8xICsgXzIpKGksIGopPC9saXRlcmFsPi4KCgogICAgICA8L3BhcmE+CgoKCjxzZWN0aW9uIGlkPSJsYW1iZGEucGFydGlhbF9mdW5jdGlvbl9hcHBsaWNhdGlvbiI+IAo8dGl0bGU+UGFydGlhbCBmdW5jdGlvbiBhcHBsaWNhdGlvbjwvdGl0bGU+Cgo8cGFyYT4KQSBiaW5kIGV4cHJlc3Npb24gaXMgaW4gZWZmZWN0IGEgPGVtcGhhc2lzPnBhcnRpYWwgZnVuY3Rpb24gYXBwbGljYXRpb248L2VtcGhhc2lzPi4KSW4gcGFydGlhbCBmdW5jdGlvbiBhcHBsaWNhdGlvbiwgc29tZSBvZiB0aGUgYXJndW1lbnRzIG9mIGEgZnVuY3Rpb24gYXJlIGJvdW5kIHRvIGZpeGVkIHZhbHVlcy4gCgkgIFRoZSByZXN1bHQgaXMgYW5vdGhlciBmdW5jdGlvbiwgd2l0aCBwb3NzaWJseSBmZXdlciBhcmd1bWVudHMuIAoJICBXaGVuIGNhbGxlZCB3aXRoIHRoZSB1bmJvdW5kIGFyZ3VtZW50cywgdGhpcyBuZXcgZnVuY3Rpb24gaW52b2tlcyB0aGUgb3JpZ2luYWwgZnVuY3Rpb24gd2l0aCB0aGUgbWVyZ2VkIGFyZ3VtZW50IGxpc3Qgb2YgYm91bmQgYW5kIHVuYm91bmQgYXJndW1lbnRzLgoJPC9wYXJhPgoKPCEtLQk8cGFyYT5UaGUgdW5kZXJseWluZyBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgQkxMIHVuaWZpZXMgdGhlIHR3byB0eXBlcyBvZiBsYW1iZGEgZXhwcmVzc2lvbnMgKGJpbmQgZXhwcmVzc2lvbnMgYW5kIGxhbWJkYSBleHByZXNzaW9ucyBjb25zaXN0aW5nIG9mIG9wZXJhdG9yIGNhbGxzKS4KCSAgSWYgb3BlcmF0b3JzIGFyZSByZWdhcmRlZCBhcyBmdW5jdGlvbnMsIGl0IGlzIGVhc3kgdG8gc2VlIHRoYXQgbGFtYmRhIGV4cHJlc3Npb25zIHVzaW5nIG9wZXJhdG9ycyBhcmUgcGFydGlhbCBmdW5jdGlvbiBhcHBsaWNhdGlvbnMgYXMgd2VsbC4gCgkgIEUuZy4gdGhlIGxhbWJkYSBleHByZXNzaW9uIDxsaXRlcmFsPl8xICsgMTwvbGl0ZXJhbD4gY2FuIGJlIHNlZW4gYXMgc3ludGFjdGljIHN1Z2FyIGZvciB0aGUgcHNldWRvIGNvZGUgPGxpdGVyYWw+YmluZChvcGVyYXRvcissIF8xLCAxKTwvbGl0ZXJhbD4uCgk8L3BhcmE+Ci0tPgoKICAgICAgPC9zZWN0aW9uPgoKCgogICAgICA8c2VjdGlvbiBpZD0ibGFtYmRhLnRlcm1pbm9sb2d5Ij4KCTx0aXRsZT5UZXJtaW5vbG9neTwvdGl0bGU+CgoJPHBhcmE+CgkgIEEgbGFtYmRhIGV4cHJlc3Npb24gZGVmaW5lcyBhIGZ1bmN0aW9uLiBBIEMrKyBsYW1iZGEgZXhwcmVzc2lvbiBjb25jcmV0ZWx5IGNvbnN0cnVjdHMgYSBmdW5jdGlvbiBvYmplY3QsIDxlbXBoYXNpcz5hIGZ1bmN0b3I8L2VtcGhhc2lzPiwgd2hlbiBldmFsdWF0ZWQuIFdlIHVzZSB0aGUgbmFtZSA8ZW1waGFzaXM+bGFtYmRhIGZ1bmN0b3I8L2VtcGhhc2lzPiB0byByZWZlciB0byBzdWNoIGEgZnVuY3Rpb24gb2JqZWN0LiAKCSAgSGVuY2UsIGluIHRoZSB0ZXJtaW5vbG9neSBhZG9wdGVkIGhlcmUsIHRoZSByZXN1bHQgb2YgZXZhbHVhdGluZyBhIGxhbWJkYSBleHByZXNzaW9uIGlzIGEgbGFtYmRhIGZ1bmN0b3IuCgk8L3BhcmE+CgogICAgICA8L3NlY3Rpb24+CgogICAgPC9zZWN0aW9uPgoKCgogIDwvc2VjdGlvbj4KCiAgPHNlY3Rpb24gaWQgPSAibGFtYmRhLnVzaW5nX2xpYnJhcnkiPgogICAgPHRpdGxlPlVzaW5nIHRoZSBsaWJyYXJ5PC90aXRsZT4KCiAgICA8cGFyYT4KVGhlIHB1cnBvc2Ugb2YgdGhpcyBzZWN0aW9uIGlzIHRvIGludHJvZHVjZSB0aGUgYmFzaWMgZnVuY3Rpb25hbGl0eSBvZiB0aGUgbGlicmFyeS4KVGhlcmUgYXJlIHF1aXRlIGEgbG90IG9mIGV4Y2VwdGlvbnMgYW5kIHNwZWNpYWwgY2FzZXMsIGJ1dCBkaXNjdXNzaW9uIG9mIHRoZW0gaXMgcG9zdHBvbmVkIHVudGlsIGxhdGVyIHNlY3Rpb25zLgoKCiAgICA8L3BhcmE+CgogICAgPHNlY3Rpb24gaWQgPSAibGFtYmRhLmludHJvZHVjdG9yeV9leGFtcGxlcyI+CiAgICAgIDx0aXRsZT5JbnRyb2R1Y3RvcnkgRXhhbXBsZXM8L3RpdGxlPgoKICAgICAgPHBhcmE+CglJbiB0aGlzIHNlY3Rpb24gd2UgZ2l2ZSBiYXNpYyBleGFtcGxlcyBvZiB1c2luZyBCTEwgbGFtYmRhIGV4cHJlc3Npb25zIGluIFNUTCBhbGdvcml0aG0gaW52b2NhdGlvbnMuIAoJV2Ugc3RhcnQgd2l0aCBzb21lIHNpbXBsZSBleHByZXNzaW9ucyBhbmQgd29yayB1cC4gCglGaXJzdCwgd2UgaW5pdGlhbGl6ZSB0aGUgZWxlbWVudHMgb2YgYSBjb250YWluZXIsIHNheSwgYSA8bGl0ZXJhbD5saXN0PC9saXRlcmFsPiwgdG8gdGhlIHZhbHVlIDxsaXRlcmFsPjE8L2xpdGVyYWw+OgoKCgk8cHJvZ3JhbWxpc3Rpbmc+CjwhW0NEQVRBW2xpc3Q8aW50PiB2KDEwKTsKZm9yX2VhY2godi5iZWdpbigpLCB2LmVuZCgpLCBfMSA9IDEpO11dPjwvcHJvZ3JhbWxpc3Rpbmc+CgoJVGhlIGV4cHJlc3Npb24gPGxpdGVyYWw+XzEgPSAxPC9saXRlcmFsPiBjcmVhdGVzIGEgbGFtYmRhIGZ1bmN0b3Igd2hpY2ggYXNzaWducyB0aGUgdmFsdWUgPGxpdGVyYWw+MTwvbGl0ZXJhbD4gdG8gZXZlcnkgZWxlbWVudCBpbiA8bGl0ZXJhbD52PC9saXRlcmFsPi48Zm9vdG5vdGU+CjxwYXJhPgpTdHJpY3RseSB0YWtlbiwgdGhlIEMrKyBzdGFuZGFyZCBkZWZpbmVzIDxsaXRlcmFsPmZvcl9lYWNoPC9saXRlcmFsPiBhcyBhIDxlbXBoYXNpcz5ub24tbW9kaWZ5aW5nIHNlcXVlbmNlIG9wZXJhdGlvbjwvZW1waGFzaXM+LCBhbmQgdGhlIGZ1bmN0aW9uIG9iamVjdCBwYXNzZWQgdG8gPGxpdGVyYWwgbW9yZWluZm89Im5vbmUiPmZvcl9lYWNoPC9saXRlcmFsPiBzaG91bGQgbm90IG1vZGlmeSBpdHMgYXJndW1lbnQuIApUaGUgcmVxdWlyZW1lbnRzIGZvciB0aGUgYXJndW1lbnRzIG9mIDxsaXRlcmFsPmZvcl9lYWNoPC9saXRlcmFsPiBhcmUgdW5uZWNlc3Nhcnkgc3RyaWN0LCBzaW5jZSBhcyBsb25nIGFzIHRoZSBpdGVyYXRvcnMgYXJlIDxlbXBoYXNpcz5tdXRhYmxlPC9lbXBoYXNpcz4sIDxsaXRlcmFsPmZvcl9lYWNoPC9saXRlcmFsPiBhY2NlcHRzIGEgZnVuY3Rpb24gb2JqZWN0IHRoYXQgY2FuIGhhdmUgc2lkZS1lZmZlY3RzIG9uIHRoZWlyIGFyZ3VtZW50LgpOZXZlcnRoZWxlc3MsIGl0IGlzIHN0cmFpZ2h0Zm9yd2FyZCB0byBwcm92aWRlIGFub3RoZXIgZnVuY3Rpb24gdGVtcGxhdGUgd2l0aCB0aGUgZnVuY3Rpb25hbGl0eSBvZjxsaXRlcmFsPnN0ZDo6Zm9yX2VhY2g8L2xpdGVyYWw+IGJ1dCBtb3JlIGZpbmUtZ3JhaW5lZCByZXF1aXJlbWVudHMgZm9yIGl0cyBhcmd1bWVudHMuCjwvcGFyYT4KPC9mb290bm90ZT4KICAgICAgPC9wYXJhPgoKICAgICAgPHBhcmE+CglOZXh0LCB3ZSBjcmVhdGUgYSBjb250YWluZXIgb2YgcG9pbnRlcnMgYW5kIG1ha2UgdGhlbSBwb2ludCB0byB0aGUgZWxlbWVudHMgaW4gdGhlIGZpcnN0IGNvbnRhaW5lciA8bGl0ZXJhbD52PC9saXRlcmFsPjoKCgk8cHJvZ3JhbWxpc3Rpbmc+CjwhW0NEQVRBW3ZlY3RvcjxpbnQqPiB2cCgxMCk7IAp0cmFuc2Zvcm0odi5iZWdpbigpLCB2LmVuZCgpLCB2cC5iZWdpbigpLCAmXzEpO11dPjwvcHJvZ3JhbWxpc3Rpbmc+CgpUaGUgZXhwcmVzc2lvbiA8bGl0ZXJhbD48IVtDREFUQVsmXzFdXT48L2xpdGVyYWw+IGNyZWF0ZXMgYSBmdW5jdGlvbiBvYmplY3QgZm9yIGdldHRpbmcgdGhlIGFkZHJlc3Mgb2YgZWFjaCBlbGVtZW50IGluIDxsaXRlcmFsPnY8L2xpdGVyYWw+LgpUaGUgYWRkcmVzc2VzIGdldCBhc3NpZ25lZCB0byB0aGUgY29ycmVzcG9uZGluZyBlbGVtZW50cyBpbiA8bGl0ZXJhbD52cDwvbGl0ZXJhbD4uCiAgICAgIDwvcGFyYT4KCiAgICAgIDxwYXJhPgoJVGhlIG5leHQgY29kZSBmcmFnbWVudCBjaGFuZ2VzIHRoZSB2YWx1ZXMgaW4gPGxpdGVyYWw+djwvbGl0ZXJhbD4uIAoJRm9yIGVhY2ggZWxlbWVudCwgdGhlIGZ1bmN0aW9uIDxsaXRlcmFsPmZvbzwvbGl0ZXJhbD4gaXMgY2FsbGVkLiAKVGhlIG9yaWdpbmFsIHZhbHVlIG9mIHRoZSBlbGVtZW50IGlzIHBhc3NlZCBhcyBhbiBhcmd1bWVudCB0byA8bGl0ZXJhbD5mb288L2xpdGVyYWw+LgpUaGUgcmVzdWx0IG9mIDxsaXRlcmFsPmZvbzwvbGl0ZXJhbD4gaXMgYXNzaWduZWQgYmFjayB0byB0aGUgZWxlbWVudDoKCgoJPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVtpbnQgZm9vKGludCk7CmZvcl9lYWNoKHYuYmVnaW4oKSwgdi5lbmQoKSwgXzEgPSBiaW5kKGZvbywgXzEpKTtdXT48L3Byb2dyYW1saXN0aW5nPgogICAgICA8L3BhcmE+CgoKICAgICAgPHBhcmE+CglUaGUgbmV4dCBzdGVwIGlzIHRvIHNvcnQgdGhlIGVsZW1lbnRzIG9mIDxsaXRlcmFsPnZwPC9saXRlcmFsPjoKCQoJPHByb2dyYW1saXN0aW5nPnNvcnQodnAuYmVnaW4oKSwgdnAuZW5kKCksICpfMSA+ICpfMik7PC9wcm9ncmFtbGlzdGluZz4KCglJbiB0aGlzIGNhbGwgdG8gPGxpdGVyYWw+c29ydDwvbGl0ZXJhbD4sIHdlIGFyZSBzb3J0aW5nIHRoZSBlbGVtZW50cyBieSB0aGVpciBjb250ZW50cyBpbiBkZXNjZW5kaW5nIG9yZGVyLiAKICAgICAgPC9wYXJhPgoKICAgICAgPHBhcmE+CglGaW5hbGx5LCB0aGUgZm9sbG93aW5nIDxsaXRlcmFsPmZvcl9lYWNoPC9saXRlcmFsPiBjYWxsIG91dHB1dHMgdGhlIHNvcnRlZCBjb250ZW50IG9mIDxsaXRlcmFsPnZwPC9saXRlcmFsPiBzZXBhcmF0ZWQgYnkgbGluZSBicmVha3M6Cgo8cHJvZ3JhbWxpc3Rpbmc+CjwhW0NEQVRBW2Zvcl9lYWNoKHZwLmJlZ2luKCksIHZwLmVuZCgpLCBjb3V0IDw8ICpfMSA8PCAnXG4nKTtdXT4KPC9wcm9ncmFtbGlzdGluZz4KCk5vdGUgdGhhdCBhIG5vcm1hbCAobm9uLWxhbWJkYSkgZXhwcmVzc2lvbiBhcyBzdWJleHByZXNzaW9uIG9mIGEgbGFtYmRhIGV4cHJlc3Npb24gaXMgZXZhbHVhdGVkIGltbWVkaWF0ZWx5LiAgClRoaXMgbWF5IGNhdXNlIHN1cnByaXNlcy4gCkZvciBpbnN0YW5jZSwgaWYgdGhlIHByZXZpb3VzIGV4YW1wbGUgaXMgcmV3cml0dGVuIGFzCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbZm9yX2VhY2godnAuYmVnaW4oKSwgdnAuZW5kKCksIGNvdXQgPDwgJ1xuJyA8PCAqXzEpO11dPgo8L3Byb2dyYW1saXN0aW5nPgp0aGUgc3ViZXhwcmVzc2lvbiA8bGl0ZXJhbD48IVtDREFUQVtjb3V0IDw8ICdcbiddXT48L2xpdGVyYWw+IGlzIGV2YWx1YXRlZCBpbW1lZGlhdGVseSBhbmQgdGhlIGVmZmVjdCBpcyB0byBvdXRwdXQgYSBzaW5nbGUgbGluZSBicmVhaywgZm9sbG93ZWQgYnkgdGhlIGVsZW1lbnRzIG9mIDxsaXRlcmFsPnZwPC9saXRlcmFsPi4KVGhlIEJMTCBwcm92aWRlcyBmdW5jdGlvbnMgPGxpdGVyYWw+Y29uc3RhbnQ8L2xpdGVyYWw+IGFuZCA8bGl0ZXJhbD52YXI8L2xpdGVyYWw+IHRvIHR1cm4gY29uc3RhbnRzIGFuZCwgcmVzcGVjdGl2ZWx5LCB2YXJpYWJsZXMgaW50byBsYW1iZGEgZXhwcmVzc2lvbnMsIGFuZCBjYW4gYmUgdXNlZCB0byBwcmV2ZW50IHRoZSBpbW1lZGlhdGUgZXZhbHVhdGlvbiBvZiBzdWJleHByZXNzaW9uczoKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVtmb3JfZWFjaCh2cC5iZWdpbigpLCB2cC5lbmQoKSwgY291dCA8PCBjb25zdGFudCgnXG4nKSA8PCAqXzEpO11dPgo8L3Byb2dyYW1saXN0aW5nPgpUaGVzZSBmdW5jdGlvbnMgYXJlIGRlc2NyaWJlZCBtb3JlIHRob3JvdWdobHkgaW4gPHhyZWYgbGlua2VuZD0ibGFtYmRhLmRlbGF5aW5nX2NvbnN0YW50c19hbmRfdmFyaWFibGVzIi8+Cgo8L3BhcmE+CgoKCgoKICAgIDwvc2VjdGlvbj4KCgogICAgPHNlY3Rpb24gaWQ9ImxhbWJkYS5wYXJhbWV0ZXJfYW5kX3JldHVybl90eXBlcyI+CiAgICAgIDx0aXRsZT5QYXJhbWV0ZXIgYW5kIHJldHVybiB0eXBlcyBvZiBsYW1iZGEgZnVuY3RvcnM8L3RpdGxlPgoKICAgICAgPHBhcmE+CglEdXJpbmcgdGhlIGludm9jYXRpb24gb2YgYSBsYW1iZGEgZnVuY3RvciwgdGhlIGFjdHVhbCBhcmd1bWVudHMgYXJlIHN1YnN0aXR1dGVkIGZvciB0aGUgcGxhY2Vob2xkZXJzLiAKCVRoZSBwbGFjZWhvbGRlcnMgZG8gbm90IGRpY3RhdGUgdGhlIHR5cGUgb2YgdGhlc2UgYWN0dWFsIGFyZ3VtZW50cy4KCVRoZSBiYXNpYyBydWxlIGlzIHRoYXQgYSBsYW1iZGEgZnVuY3Rpb24gY2FuIGJlIGNhbGxlZCB3aXRoIGFyZ3VtZW50cyBvZiBhbnkgdHlwZXMsIGFzIGxvbmcgYXMgdGhlIGxhbWJkYSBleHByZXNzaW9uIHdpdGggc3Vic3RpdHV0aW9ucyBwZXJmb3JtZWQgaXMgYSB2YWxpZCBDKysgZXhwcmVzc2lvbi4gCglBcyBhbiBleGFtcGxlLCB0aGUgZXhwcmVzc2lvbgoJPGxpdGVyYWw+XzEgKyBfMjwvbGl0ZXJhbD4gY3JlYXRlcyBhIGJpbmFyeSBsYW1iZGEgZnVuY3Rvci4gCglJdCBjYW4gYmUgY2FsbGVkIHdpdGggdHdvIG9iamVjdHMgb2YgYW55IHR5cGVzIDxsaXRlcmFsPkE8L2xpdGVyYWw+IGFuZCA8bGl0ZXJhbD5CPC9saXRlcmFsPiBmb3Igd2hpY2ggPGxpdGVyYWw+b3BlcmF0b3IrKEEsQik8L2xpdGVyYWw+IGlzIGRlZmluZWQgKGFuZCBmb3Igd2hpY2ggQkxMIGtub3dzIHRoZSByZXR1cm4gdHlwZSBvZiB0aGUgb3BlcmF0b3IsIHNlZSBiZWxvdykuCiAgICAgIDwvcGFyYT4KCiAgICAgIDxwYXJhPgoJQysrIGxhY2tzIGEgbWVjaGFuaXNtIHRvIHF1ZXJ5IGEgdHlwZSBvZiBhbiBleHByZXNzaW9uLiAKCUhvd2V2ZXIsIHRoaXMgcHJlY2lzZSBtZWNoYW5pc20gaXMgY3J1Y2lhbCBmb3IgdGhlIGltcGxlbWVudGF0aW9uIG9mIEMrKyBsYW1iZGEgZXhwcmVzc2lvbnMuCglDb25zZXF1ZW50bHksIEJMTCBpbmNsdWRlcyBhIHNvbWV3aGF0IGNvbXBsZXggdHlwZSBkZWR1Y3Rpb24gc3lzdGVtIHdoaWNoIHVzZXMgYSBzZXQgb2YgdHJhaXRzIGNsYXNzZXMgZm9yIGRlZHVjaW5nIHRoZSByZXN1bHRpbmcgdHlwZSBvZiBsYW1iZGEgZnVuY3Rpb25zLgoJSXQgaGFuZGxlcyBleHByZXNzaW9ucyB3aGVyZSB0aGUgb3BlcmFuZHMgYXJlIG9mIGJ1aWx0LWluIHR5cGVzIGFuZCBtYW55IG9mIHRoZSBleHByZXNzaW9ucyB3aXRoIG9wZXJhbmRzIG9mIHN0YW5kYXJkIGxpYnJhcnkgdHlwZXMuCglNYW55IG9mIHRoZSB1c2VyIGRlZmluZWQgdHlwZXMgYXJlIGNvdmVyZWQgYXMgd2VsbCwgcGFydGljdWxhcmx5IGlmIHRoZSB1c2VyIGRlZmluZWQgb3BlcmF0b3JzIG9iZXkgbm9ybWFsIGNvbnZlbnRpb25zIGluIGRlZmluaW5nIHRoZSByZXR1cm4gdHlwZXMuIAogICAgICA8L3BhcmE+CgogICAgICA8IS0tIFRPRE86IG1vdmUgIHRoaXMgZm9yd2FyZCwgYW5kIGp1c3QgcmVmZXIgdG8gaXQuIC0tPgogICAgICA8cGFyYT4KCVRoZXJlIGFyZSwgaG93ZXZlciwgY2FzZXMgd2hlbiB0aGUgcmV0dXJuIHR5cGUgY2Fubm90IGJlIGRlZHVjZWQuIEZvciBleGFtcGxlLCBzdXBwb3NlIHlvdSBoYXZlIGRlZmluZWQ6CgoJPHByb2dyYW1saXN0aW5nPkMgb3BlcmF0b3IrKEEsIEIpOzwvcHJvZ3JhbWxpc3Rpbmc+CgoJVGhlIGZvbGxvd2luZyBsYW1iZGEgZnVuY3Rpb24gaW52b2NhdGlvbiBmYWlscywgc2luY2UgdGhlIHJldHVybiB0eXBlIGNhbm5vdCBiZSBkZWR1Y2VkOgoKCTxwcm9ncmFtbGlzdGluZz5BIGE7IEIgYjsgKF8xICsgXzIpKGEsIGIpOzwvcHJvZ3JhbWxpc3Rpbmc+CiAgICAgIDwvcGFyYT4KCiAgICAgIDxwYXJhPgoJVGhlcmUgYXJlIHR3byBhbHRlcm5hdGl2ZSBzb2x1dGlvbnMgdG8gdGhpcy4gCglUaGUgZmlyc3QgaXMgdG8gZXh0ZW5kIHRoZSBCTEwgdHlwZSBkZWR1Y3Rpb24gc3lzdGVtIHRvIGNvdmVyIHlvdXIgb3duIHR5cGVzIChzZWUgPHhyZWYgbGlua2VuZD0ibGFtYmRhLmV4dGVuZGluZyIvPikuIAoJVGhlIHNlY29uZCBpcyB0byB1c2UgYSBzcGVjaWFsIGxhbWJkYSBleHByZXNzaW9uICg8bGl0ZXJhbD5yZXQ8L2xpdGVyYWw+KSB3aGljaCBkZWZpbmVzIHRoZSByZXR1cm4gdHlwZSBpbiBwbGFjZSAoc2VlIDx4cmVmIGxpbmtlbmQgPSAibGFtYmRhLm92ZXJyaWRpbmdfZGVkdWNlZF9yZXR1cm5fdHlwZSIvPik6CgoJPHByb2dyYW1saXN0aW5nPjwhW0NEQVRBW0EgYTsgQiBiOyByZXQ8Qz4oXzEgKyBfMikoYSwgYik7XV0+PC9wcm9ncmFtbGlzdGluZz4KICAgICAgPC9wYXJhPgoKICAgICAgPHBhcmE+CglGb3IgYmluZCBleHByZXNzaW9ucywgdGhlIHJldHVybiB0eXBlIGNhbiBiZSBkZWZpbmVkIGFzIGEgdGVtcGxhdGUgYXJndW1lbnQgb2YgdGhlIGJpbmQgZnVuY3Rpb24gYXMgd2VsbDogCgk8cHJvZ3JhbWxpc3Rpbmc+PCFbQ0RBVEFbYmluZDxpbnQ+KGZvbywgXzEsIF8yKTtdXT48L3Byb2dyYW1saXN0aW5nPgoKPCEtLQoJQSByYXJlIGNhc2UsIHdoZXJlIHRoZSA8bGl0ZXJhbD48IVtDREFUQVtyZXQ8dHlwZT4oYmluZCguLi4pKV1dPjwvbGl0ZXJhbD4gc3ludGF4IGRvZXMgbm90IHdvcmssIGJ1dAoJPGxpdGVyYWw+PCFbQ0RBVEFbYmluZDx0eXBlPiguLi4pXV0+PC9saXRlcmFsPiBkb2VzLCBpcyBleHBsYWluZWQgaW4gPHhyZWYgbGlua2VuZD0ibGFtYmRhLm51bGxhcnlfZnVuY3RvcnNfYW5kX3JldCIvPi4KLS0+CiAgICAgIDwvcGFyYT4KICAgIDwvc2VjdGlvbj4KCiAgICA8c2VjdGlvbiBpZD0ibGFtYmRhLmFjdHVhbF9hcmd1bWVudHNfdG9fbGFtYmRhX2Z1bmN0b3JzIj4KICAgICAgPHRpdGxlPkFib3V0IGFjdHVhbCBhcmd1bWVudHMgdG8gbGFtYmRhIGZ1bmN0b3JzPC90aXRsZT4KCjwhLS0gICAgICA8cGFyYT48ZW1waGFzaXM+VGhpcyBzZWN0aW9uIGlzIG5vIGxvbmdlciAob3IgY3VycmVudGx5KSByZWxldmFudDsKICAgICAgIGFjdWFsIGFyZ3VtZW50cyBjYW4gYmUgbm9uLWNvbnN0IHJ2YWx1ZXMuCiAgICAgICBUaGUgc2VjdGlvbiBjYW4sIGhvd2V2ZXIsIGJlY29tZSByZWxldmFudCBhZ2FpbiwgaWYgaW4gdGhlIGZ1dHVyZSBCTEwgd2lsbCBzdXBwb3J0CiAgICAgICBsYW1iZGEgZnVuY3RvcnMgd2l0aCBoaWdoZXIgYXJpdGllcyB0aGFuIDMuPC9lbXBoYXNpcz48L3BhcmE+IC0tPgoKICAgICAgPHBhcmE+QSBnZW5lcmFsIHJlc3RyaWN0aW9uIGZvciB0aGUgYWN0dWFsIGFyZ3VtZW50cyBpcyB0aGF0IHRoZXkgY2Fubm90IGJlIG5vbi1jb25zdCBydmFsdWVzLiAKCUZvciBleGFtcGxlOgoKPHByb2dyYW1saXN0aW5nPgppbnQgaSA9IDE7IGludCBqID0gMjsgCihfMSArIF8yKShpLCBqKTsgLy8gb2sKKF8xICsgXzIpKDEsIDIpOyAvLyBlcnJvciAoISkKPC9wcm9ncmFtbGlzdGluZz4KCglUaGlzIHJlc3RyaWN0aW9uIGlzIG5vdCBhcyBiYWQgYXMgaXQgbWF5IGxvb2suIAoJU2luY2UgdGhlIGxhbWJkYSBmdW5jdG9ycyBhcmUgbW9zdCBvZnRlbiBjYWxsZWQgaW5zaWRlIFNUTC1hbGdvcml0aG1zLCAKCXRoZSBhcmd1bWVudHMgb3JpZ2luYXRlIGZyb20gZGVyZWZlcmVuY2luZyBpdGVyYXRvcnMgYW5kIHRoZSBkZXJlZmVyZW5jaW5nIG9wZXJhdG9ycyBzZWxkb20gcmV0dXJuIHJ2YWx1ZXMuCglBbmQgZm9yIHRoZSBjYXNlcyB3aGVyZSB0aGV5IGRvLCB0aGVyZSBhcmUgd29ya2Fyb3VuZHMgZGlzY3Vzc2VkIGluIAo8eHJlZiBsaW5rZW5kPSJsYW1iZGEucnZhbHVlc19hc19hY3R1YWxfYXJndW1lbnRzIi8+LgoKCiAgICAgIDwvcGFyYT4KCiAgICA8L3NlY3Rpb24+CgoKPHNlY3Rpb24gaWQ9ImxhbWJkYS5zdG9yaW5nX2JvdW5kX2FyZ3VtZW50cyI+Cgo8dGl0bGU+U3RvcmluZyBib3VuZCBhcmd1bWVudHMgaW4gbGFtYmRhIGZ1bmN0aW9uczwvdGl0bGU+CiAgICAgIAo8cGFyYT4KCkJ5IGRlZmF1bHQsIHRlbXBvcmFyeSBjb25zdCBjb3BpZXMgb2YgdGhlIGJvdW5kIGFyZ3VtZW50cyBhcmUgc3RvcmVkIAppbiB0aGUgbGFtYmRhIGZ1bmN0b3IuCgpUaGlzIG1lYW5zIHRoYXQgdGhlIHZhbHVlIG9mIGEgYm91bmQgYXJndW1lbnQgaXMgZml4ZWQgYXQgdGhlIHRpbWUgb2YgdGhlIApjcmVhdGlvbiBvZiB0aGUgbGFtYmRhIGZ1bmN0aW9uIGFuZCByZW1haW5zIGNvbnN0YW50IGR1cmluZyB0aGUgbGlmZXRpbWUgCm9mIHRoZSBsYW1iZGEgZnVuY3Rpb24gb2JqZWN0LgpGb3IgZXhhbXBsZToKPHByb2dyYW1saXN0aW5nPgppbnQgaSA9IDE7CihfMSA9IDIsIF8xICsgaSkoaSk7CjwvcHJvZ3JhbWxpc3Rpbmc+ClRoZSBjb21tYSBvcGVyYXRvciBpcyBvdmVybG9hZGVkIHRvIGNvbWJpbmUgbGFtYmRhIGV4cHJlc3Npb25zIGludG8gYSBzZXF1ZW5jZTsKdGhlIHJlc3VsdGluZyB1bmFyeSBsYW1iZGEgZnVuY3RvciBmaXJzdCBhc3NpZ25zIDIgdG8gaXRzIGFyZ3VtZW50LCAKdGhlbiBhZGRzIHRoZSB2YWx1ZSBvZiA8bGl0ZXJhbD5pPC9saXRlcmFsPiB0byBpdC4KVGhlIHZhbHVlIG9mIHRoZSBleHByZXNzaW9uIGluIHRoZSBsYXN0IGxpbmUgaXMgMywgbm90IDQuIApJbiBvdGhlciB3b3JkcywgdGhlIGxhbWJkYSBleHByZXNzaW9uIHRoYXQgaXMgY3JlYXRlZCBpcwo8bGl0ZXJhbD5sYW1iZGEgeC4oeCA9IDIsIHggKyAxKTwvbGl0ZXJhbD4gcmF0aGVyIHRoYW4KPGxpdGVyYWw+bGFtYmRhIHguKHggPSAyLCB4ICsgaSk8L2xpdGVyYWw+LgogICAgICAKPC9wYXJhPgoKPHBhcmE+CgpBcyBzYWlkLCB0aGlzIGlzIHRoZSBkZWZhdWx0IGJlaGF2aW9yIGZvciB3aGljaCB0aGVyZSBhcmUgZXhjZXB0aW9ucy4KVGhlIGV4YWN0IHJ1bGVzIGFyZSBhcyBmb2xsb3dzOgoKPGl0ZW1pemVkbGlzdD4KCjxsaXN0aXRlbT4KCjxwYXJhPgoKVGhlIHByb2dyYW1tZXIgY2FuIGNvbnRyb2wgdGhlIHN0b3JpbmcgbWVjaGFuaXNtIHdpdGggPGxpdGVyYWw+cmVmPC9saXRlcmFsPiAKYW5kIDxsaXRlcmFsPmNyZWY8L2xpdGVyYWw+IHdyYXBwZXJzIDx4cmVmIGxpbmtlbmQ9ImNpdDpib29zdDo6cmVmIi8+LgoKV3JhcHBpbmcgYW4gYXJndW1lbnQgd2l0aCA8bGl0ZXJhbD5yZWY8L2xpdGVyYWw+LCBvciA8bGl0ZXJhbD5jcmVmPC9saXRlcmFsPiwgCmluc3RydWN0cyB0aGUgbGlicmFyeSB0byBzdG9yZSB0aGUgYXJndW1lbnQgYXMgYSByZWZlcmVuY2UsIApvciBhcyBhIHJlZmVyZW5jZSB0byBjb25zdCByZXNwZWN0aXZlbHkuCgpGb3IgZXhhbXBsZSwgaWYgd2UgcmV3cml0ZSB0aGUgcHJldmlvdXMgZXhhbXBsZSBhbmQgd3JhcCB0aGUgdmFyaWFibGUgCjxsaXRlcmFsPmk8L2xpdGVyYWw+IHdpdGggPGxpdGVyYWw+cmVmPC9saXRlcmFsPiwgCndlIGFyZSBjcmVhdGluZyB0aGUgbGFtYmRhIGV4cHJlc3Npb24gPGxpdGVyYWw+bGFtYmRhIHguKHggPSAyLCB4ICsgaSk8L2xpdGVyYWw+IAphbmQgdGhlIHZhbHVlIG9mIHRoZSBleHByZXNzaW9uIGluIHRoZSBsYXN0IGxpbmUgd2lsbCBiZSA0OgoKPHByb2dyYW1saXN0aW5nPgppID0gMTsKKF8xID0gMiwgXzEgKyByZWYoaSkpKGkpOwo8L3Byb2dyYW1saXN0aW5nPgoKTm90ZSB0aGF0IDxsaXRlcmFsPnJlZjwvbGl0ZXJhbD4gYW5kIDxsaXRlcmFsPmNyZWY8L2xpdGVyYWw+IGFyZSBkaWZmZXJlbnQKZnJvbSA8bGl0ZXJhbD52YXI8L2xpdGVyYWw+IGFuZCA8bGl0ZXJhbD5jb25zdGFudDwvbGl0ZXJhbD4uCgpXaGlsZSB0aGUgbGF0dGVyIG9uZXMgY3JlYXRlIGxhbWJkYSBmdW5jdG9ycywgdGhlIGZvcm1lciBkbyBub3QuIApGb3IgZXhhbXBsZToKCjxwcm9ncmFtbGlzdGluZz4KaW50IGk7IAp2YXIoaSkgPSAxOyAvLyBvawpyZWYoaSkgPSAxOyAvLyBub3Qgb2ssIHJlZihpKSBpcyBub3QgYSBsYW1iZGEgZnVuY3Rvcgo8L3Byb2dyYW1saXN0aW5nPgoKVGhlIGZ1bmN0aW9ucyA8bGl0ZXJhbD5yZWY8L2xpdGVyYWw+IGFuZCA8bGl0ZXJhbD5jcmVmPC9saXRlcmFsPiBtb3N0bHkgCmV4aXN0IGZvciBoaXN0b3JpY2FsIHJlYXNvbnMsCmFuZCA8bGl0ZXJhbD5yZWY8L2xpdGVyYWw+IGNhbiBhbHdheXMKYmUgcmVwbGFjZWQgd2l0aCA8bGl0ZXJhbD52YXI8L2xpdGVyYWw+LCBhbmQgPGxpdGVyYWw+Y3JlZjwvbGl0ZXJhbD4gd2l0aAo8bGl0ZXJhbD5jb25zdGFudF9yZWY8L2xpdGVyYWw+LiAKU2VlIDx4cmVmIGxpbmtlbmQ9ImxhbWJkYS5kZWxheWluZ19jb25zdGFudHNfYW5kX3ZhcmlhYmxlcyIvPiBmb3IgZGV0YWlscy4KVGhlIDxsaXRlcmFsPnJlZjwvbGl0ZXJhbD4gYW5kIDxsaXRlcmFsPmNyZWY8L2xpdGVyYWw+IGZ1bmN0aW9ucyBhcmUKZ2VuZXJhbCBwdXJwb3NlIHV0aWxpdHkgZnVuY3Rpb25zIGluIEJvb3N0LCBhbmQgaGVuY2UgZGVmaW5lZCBkaXJlY3RseQppbiB0aGUgPGxpdGVyYWwgbW9yZWluZm89Im5vbmUiPmJvb3N0PC9saXRlcmFsPiBuYW1lc3BhY2UuCgo8L3BhcmE+CjwvbGlzdGl0ZW0+CgkgIAo8bGlzdGl0ZW0+CjxwYXJhPgpBcnJheSB0eXBlcyBjYW5ub3QgYmUgY29waWVkLCB0aGV5IGFyZSB0aHVzIHN0b3JlZCBhcyBjb25zdCByZWZlcmVuY2UgYnkgZGVmYXVsdC4KPC9wYXJhPgo8L2xpc3RpdGVtPgoKPGxpc3RpdGVtPgoKPHBhcmE+IApGb3Igc29tZSBleHByZXNzaW9ucyBpdCBtYWtlcyBtb3JlIHNlbnNlIHRvIHN0b3JlIHRoZSBhcmd1bWVudHMgYXMgcmVmZXJlbmNlcy4gCgpGb3IgZXhhbXBsZSwgdGhlIG9idmlvdXMgaW50ZW50aW9uIG9mIHRoZSBsYW1iZGEgZXhwcmVzc2lvbiAKPGxpdGVyYWw+aSArPSBfMTwvbGl0ZXJhbD4gaXMgdGhhdCBjYWxscyB0byB0aGUgbGFtYmRhIGZ1bmN0b3IgYWZmZWN0IHRoZSAKdmFsdWUgb2YgdGhlIHZhcmlhYmxlIDxsaXRlcmFsPmk8L2xpdGVyYWw+LCAKcmF0aGVyIHRoYW4gc29tZSB0ZW1wb3JhcnkgY29weSBvZiBpdC4gCgpBcyBhbm90aGVyIGV4YW1wbGUsIHRoZSBzdHJlYW1pbmcgb3BlcmF0b3JzIHRha2UgdGhlaXIgbGVmdG1vc3QgYXJndW1lbnQgCmFzIG5vbi1jb25zdCByZWZlcmVuY2VzLiAKClRoZSBleGFjdCBydWxlcyBhcmU6Cgo8aXRlbWl6ZWRsaXN0Pgo8bGlzdGl0ZW0+CjxwYXJhPlRoZSBsZWZ0IGFyZ3VtZW50IG9mIGNvbXBvdW5kIGFzc2lnbm1lbnQgb3BlcmF0b3JzICg8bGl0ZXJhbD4rPTwvbGl0ZXJhbD4sIDxsaXRlcmFsPio9PC9saXRlcmFsPiwgZXRjLikgYXJlIHN0b3JlZCBhcyByZWZlcmVuY2VzIHRvIG5vbi1jb25zdC48L3BhcmE+CjwvbGlzdGl0ZW0+Cgo8bGlzdGl0ZW0+CjxwYXJhPklmIHRoZSBsZWZ0IGFyZ3VtZW50IG9mIDxsaXRlcmFsPjwhW0NEQVRBWzw8XV0+PC9saXRlcmFsPiBvciA8bGl0ZXJhbD48IVtDREFUQVs+Pl1dPjwvbGl0ZXJhbD4gIG9wZXJhdG9yIGlzIGRlcml2ZWQgZnJvbSBhbiBpbnN0YW50aWF0aW9uIG9mIDxsaXRlcmFsPmJhc2ljX29zdHJlYW08L2xpdGVyYWw+IG9yIHJlc3BlY3RpdmVseSBmcm9tIDxsaXRlcmFsPmJhc2ljX2lzdHJlYW08L2xpdGVyYWw+LCB0aGUgYXJndW1lbnQgaXMgc3RvcmVkIGFzIGEgcmVmZXJlbmNlIHRvIG5vbi1jb25zdC4gCkZvciBhbGwgb3RoZXIgdHlwZXMsIHRoZSBhcmd1bWVudCBpcyBzdG9yZWQgYXMgYSBjb3B5Lgo8L3BhcmE+CjwvbGlzdGl0ZW0+Cgo8bGlzdGl0ZW0+CjxwYXJhPgpJbiBwb2ludGVyIGFyaXRobWV0aWMgZXhwcmVzc2lvbnMsIG5vbi1jb25zdCBhcnJheSB0eXBlcyBhcmUgc3RvcmVkIGFzIG5vbi1jb25zdCByZWZlcmVuY2VzLgpUaGlzIGlzIHRvIHByZXZlbnQgcG9pbnRlciBhcml0aG1ldGljIG1ha2luZyBub24tY29uc3QgYXJyYXlzIGNvbnN0LiAKCjwvcGFyYT4KPC9saXN0aXRlbT4gCgo8L2l0ZW1pemVkbGlzdD4KCjwvcGFyYT4KPC9saXN0aXRlbT4KCjwvaXRlbWl6ZWRsaXN0Pgo8L3BhcmE+Cgo8L3NlY3Rpb24+Cgo8L3NlY3Rpb24+Cgo8c2VjdGlvbiBpZD0ibGFtYmRhLmxlX2luX2RldGFpbHMiPgo8dGl0bGU+TGFtYmRhIGV4cHJlc3Npb25zIGluIGRldGFpbHM8L3RpdGxlPgoKPHBhcmE+ClRoaXMgc2VjdGlvbiBkZXNjcmliZXMgZGlmZmVyZW50IGNhdGVnb3JpZXMgb2YgbGFtYmRhIGV4cHJlc3Npb25zIGluIGRldGFpbHMuCldlIGRldm90ZSBhIHNlcGFyYXRlIHNlY3Rpb24gZm9yIGVhY2ggb2YgdGhlIHBvc3NpYmxlIGZvcm1zIG9mIGEgbGFtYmRhIGV4cHJlc3Npb24uCgoKPC9wYXJhPgoKPHNlY3Rpb24gaWQ9ImxhbWJkYS5wbGFjZWhvbGRlcnMiPgo8dGl0bGU+UGxhY2Vob2xkZXJzPC90aXRsZT4KCjxwYXJhPgpUaGUgQkxMIGRlZmluZXMgdGhyZWUgcGxhY2Vob2xkZXIgdHlwZXM6IDxsaXRlcmFsPnBsYWNlaG9sZGVyMV90eXBlPC9saXRlcmFsPiwgPGxpdGVyYWw+cGxhY2Vob2xkZXIyX3R5cGU8L2xpdGVyYWw+IGFuZCA8bGl0ZXJhbD5wbGFjZWhvbGRlcjNfdHlwZTwvbGl0ZXJhbD4uIApCTEwgaGFzIGEgcHJlZGVmaW5lZCBwbGFjZWhvbGRlciB2YXJpYWJsZSBmb3IgZWFjaCBwbGFjZWhvbGRlciB0eXBlOiA8bGl0ZXJhbD5fMTwvbGl0ZXJhbD4sIDxsaXRlcmFsPl8yPC9saXRlcmFsPiBhbmQgPGxpdGVyYWw+XzM8L2xpdGVyYWw+LiAKSG93ZXZlciwgdGhlIHVzZXIgaXMgbm90IGZvcmNlZCB0byB1c2UgdGhlc2UgcGxhY2Vob2xkZXJzLiAKSXQgaXMgZWFzeSB0byBkZWZpbmUgcGxhY2Vob2xkZXJzIHdpdGggYWx0ZXJuYXRpdmUgbmFtZXMuClRoaXMgaXMgZG9uZSBieSBkZWZpbmluZyBuZXcgdmFyaWFibGVzIG9mIHBsYWNlaG9sZGVyIHR5cGVzLiAKRm9yIGV4YW1wbGU6Cgo8cHJvZ3JhbWxpc3Rpbmc+Ym9vc3Q6OmxhbWJkYTo6cGxhY2Vob2xkZXIxX3R5cGUgWDsKYm9vc3Q6OmxhbWJkYTo6cGxhY2Vob2xkZXIyX3R5cGUgWTsKYm9vc3Q6OmxhbWJkYTo6cGxhY2Vob2xkZXIzX3R5cGUgWjsKPC9wcm9ncmFtbGlzdGluZz4KCldpdGggdGhlc2UgdmFyaWFibGVzIGRlZmluZWQsIDxsaXRlcmFsPlggKz0gWSAqIFo8L2xpdGVyYWw+IGlzIGVxdWl2YWxlbnQgdG8gPGxpdGVyYWw+XzEgKz0gXzIgKiBfMzwvbGl0ZXJhbD4uCjwvcGFyYT4KCjxwYXJhPgpUaGUgdXNlIG9mIHBsYWNlaG9sZGVycyBpbiB0aGUgbGFtYmRhIGV4cHJlc3Npb24gZGV0ZXJtaW5lcyB3aGV0aGVyIHRoZSByZXN1bHRpbmcgZnVuY3Rpb24gaXMgbnVsbGFyeSwgdW5hcnksIGJpbmFyeSBvciAzLWFyeS4gClRoZSBoaWdoZXN0IHBsYWNlaG9sZGVyIGluZGV4IGlzIGRlY2lzaXZlLiBGb3IgZXhhbXBsZToKCjxwcm9ncmFtbGlzdGluZz4KXzEgKyA1ICAgICAgICAgICAgICAvLyB1bmFyeQpfMSAqIF8xICsgXzEgICAgICAgIC8vIHVuYXJ5Cl8xICsgXzIgICAgICAgICAgICAgLy8gYmluYXJ5CmJpbmQoZiwgXzEsIF8yLCBfMykgLy8gMy1hcnkKXzMgKyAxMCAgICAgICAgICAgICAvLyAzLWFyeQo8L3Byb2dyYW1saXN0aW5nPgoKTm90ZSB0aGF0IHRoZSBsYXN0IGxpbmUgY3JlYXRlcyBhIDMtYXJ5IGZ1bmN0aW9uLCB3aGljaCBhZGRzIDxsaXRlcmFsPjEwPC9saXRlcmFsPiB0byBpdHMgPGVtcGhhc2lzPnRoaXJkPC9lbXBoYXNpcz4gYXJndW1lbnQuIApUaGUgZmlyc3QgdHdvIGFyZ3VtZW50cyBhcmUgZGlzY2FyZGVkLgpGdXJ0aGVybW9yZSwgbGFtYmRhIGZ1bmN0b3JzIG9ubHkgaGF2ZSBhIG1pbmltdW0gYXJpdHkuCk9uZSBjYW4gYWx3YXlzIHByb3ZpZGUgbW9yZSBhcmd1bWVudHMgKHVwIHRoZSBudW1iZXIgb2Ygc3VwcG9ydGVkIHBsYWNlaG9sZGVycykKdGhhdCBpcyByZWFsbHkgbmVlZGVkLgpUaGUgcmVtYWluaW5nIGFyZ3VtZW50cyBhcmUganVzdCBkaXNjYXJkZWQuCkZvciBleGFtcGxlOgoKPHByb2dyYW1saXN0aW5nPgppbnQgaSwgaiwgazsgCl8xKGksIGosIGspICAgICAgICAvLyByZXR1cm5zIGksIGRpc2NhcmRzIGogYW5kIGsKKF8yICsgXzIpKGksIGosIGspIC8vIHJldHVybnMgaitqLCBkaXNjYXJkcyBpIGFuZCBrCjwvcHJvZ3JhbWxpc3Rpbmc+CgpTZWUKPHhyZWYgbGlua2VuZD0ibGFtYmRhLndoeV93ZWFrX2FyaXR5Ii8+IGZvciB0aGUgZGVzaWduIHJhdGlvbmFsZSBiZWhpbmQgdGhpcwpmdW5jdGlvbmFsaXR5LgoKPC9wYXJhPgoKPHBhcmE+CkluIGFkZGl0aW9uIHRvIHRoZXNlIHRocmVlIHBsYWNlaG9sZGVyIHR5cGVzLCB0aGVyZSBpcyBhbHNvIGEgZm91cnRoIHBsYWNlaG9sZGVyIHR5cGUgPGxpdGVyYWw+cGxhY2Vob2xkZXJFX3R5cGU8L2xpdGVyYWw+LgpUaGUgdXNlIG9mIHRoaXMgcGxhY2Vob2xkZXIgaXMgZGVmaW5lZCBpbiA8eHJlZiBsaW5rZW5kPSJsYW1iZGEuZXhjZXB0aW9ucyIvPiBkZXNjcmliaW5nIGV4Y2VwdGlvbiBoYW5kbGluZyBpbiBsYW1iZGEgZXhwcmVzc2lvbnMuIAo8L3BhcmE+Cgo8cGFyYT5XaGVuIGFuIGFjdHVhbCBhcmd1bWVudCBpcyBzdXBwbGllZCBmb3IgYSBwbGFjZWhvbGRlciwgdGhlIHBhcmFtZXRlciBwYXNzaW5nIG1vZGUgaXMgYWx3YXlzIGJ5IHJlZmVyZW5jZS4gClRoaXMgbWVhbnMgdGhhdCBhbnkgc2lkZS1lZmZlY3RzIHRvIHRoZSBwbGFjZWhvbGRlciBhcmUgcmVmbGVjdGVkIHRvIHRoZSBhY3R1YWwgYXJndW1lbnQuIApGb3IgZXhhbXBsZToKCgo8cHJvZ3JhbWxpc3Rpbmc+CjwhW0NEQVRBW2ludCBpID0gMTsgCihfMSArPSAyKShpKTsgICAgICAgICAvLyBpIGlzIG5vdyAzCigrK18xLCBjb3V0IDw8IF8xKShpKSAvLyBpIGlzIG5vdyA0LCBvdXRwdXRzIDRdXT4KPC9wcm9ncmFtbGlzdGluZz4KPC9wYXJhPgoKPC9zZWN0aW9uPgoKPHNlY3Rpb24gaWQ9ImxhbWJkYS5vcGVyYXRvcl9leHByZXNzaW9ucyI+Cjx0aXRsZT5PcGVyYXRvciBleHByZXNzaW9uczwvdGl0bGU+Cgo8cGFyYT4KVGhlIGJhc2ljIHJ1bGUgaXMgdGhhdCBhbnkgQysrIG9wZXJhdG9yIGludm9jYXRpb24gd2l0aCBhdCBsZWFzdCBvbmUgYXJndW1lbnQgYmVpbmcgYSBsYW1iZGEgZXhwcmVzc2lvbiBpcyBpdHNlbGYgYSBsYW1iZGEgZXhwcmVzc2lvbi4KQWxtb3N0IGFsbCBvdmVybG9hZGFibGUgb3BlcmF0b3JzIGFyZSBzdXBwb3J0ZWQuIApGb3IgZXhhbXBsZSwgdGhlIGZvbGxvd2luZyBpcyBhIHZhbGlkIGxhbWJkYSBleHByZXNzaW9uOgoKPHByb2dyYW1saXN0aW5nPjwhW0NEQVRBW2NvdXQgPDwgXzEsIF8yW18zXSA9IF8xICYmIGZhbHNlXV0+PC9wcm9ncmFtbGlzdGluZz4KPC9wYXJhPgoKPHBhcmE+Ckhvd2V2ZXIsIHRoZXJlIGFyZSBzb21lIHJlc3RyaWN0aW9ucyB0aGF0IG9yaWdpbmF0ZSBmcm9tIHRoZSBDKysgb3BlcmF0b3Igb3ZlcmxvYWRpbmcgcnVsZXMsIGFuZCBzb21lIHNwZWNpYWwgY2FzZXMuCjwvcGFyYT4KCgo8c2VjdGlvbj4KPHRpdGxlPk9wZXJhdG9ycyB0aGF0IGNhbm5vdCBiZSBvdmVybG9hZGVkPC90aXRsZT4KCjxwYXJhPgpTb21lIG9wZXJhdG9ycyBjYW5ub3QgYmUgb3ZlcmxvYWRlZCBhdCBhbGwgKDxsaXRlcmFsPjo6PC9saXRlcmFsPiwgPGxpdGVyYWw+LjwvbGl0ZXJhbD4sIDxsaXRlcmFsPi4qPC9saXRlcmFsPikuCkZvciBzb21lIG9wZXJhdG9ycywgdGhlIHJlcXVpcmVtZW50cyBvbiByZXR1cm4gdHlwZXMgcHJldmVudCB0aGVtIHRvIGJlIG92ZXJsb2FkZWQgdG8gY3JlYXRlIGxhbWJkYSBmdW5jdG9ycy4KVGhlc2Ugb3BlcmF0b3JzIGFyZSA8bGl0ZXJhbD4tPi48L2xpdGVyYWw+LCA8bGl0ZXJhbD4tPjwvbGl0ZXJhbD4sIDxsaXRlcmFsPm5ldzwvbGl0ZXJhbD4sIDxsaXRlcmFsPm5ld1tdPC9saXRlcmFsPiwgPGxpdGVyYWw+ZGVsZXRlPC9saXRlcmFsPiwgPGxpdGVyYWw+ZGVsZXRlW108L2xpdGVyYWw+IGFuZCA8bGl0ZXJhbD4/OjwvbGl0ZXJhbD4gKHRoZSBjb25kaXRpb25hbCBvcGVyYXRvcikuCjwvcGFyYT4KCjwvc2VjdGlvbj4KCjxzZWN0aW9uIGlkPSJsYW1iZGEuYXNzaWdubWVudF9hbmRfc3Vic2NyaXB0Ij4KPHRpdGxlPkFzc2lnbm1lbnQgYW5kIHN1YnNjcmlwdCBvcGVyYXRvcnM8L3RpdGxlPgoKPHBhcmE+ClRoZXNlIG9wZXJhdG9ycyBtdXN0IGJlIGltcGxlbWVudGVkIGFzIGNsYXNzIG1lbWJlcnMuIApDb25zZXF1ZW50bHksIHRoZSBsZWZ0IG9wZXJhbmQgbXVzdCBiZSBhIGxhbWJkYSBleHByZXNzaW9uLiBGb3IgZXhhbXBsZToKCjxwcm9ncmFtbGlzdGluZz4KaW50IGk7IApfMSA9IGk7ICAgICAgLy8gb2sKaSA9IF8xOyAgICAgIC8vIG5vdCBvay4gaSBpcyBub3QgYSBsYW1iZGEgZXhwcmVzc2lvbgo8L3Byb2dyYW1saXN0aW5nPgoKVGhlcmUgaXMgYSBzaW1wbGUgc29sdXRpb24gYXJvdW5kIHRoaXMgbGltaXRhdGlvbiwgZGVzY3JpYmVkIGluIDx4cmVmIGxpbmtlbmQ9ImxhbWJkYS5kZWxheWluZ19jb25zdGFudHNfYW5kX3ZhcmlhYmxlcyIvPi4KSW4gc2hvcnQsIAp0aGUgbGVmdCBoYW5kIGFyZ3VtZW50IGNhbiBiZSBleHBsaWNpdGx5IHR1cm5lZCBpbnRvIGEgbGFtYmRhIGZ1bmN0b3IgYnkgd3JhcHBpbmcgaXQgd2l0aCBhIHNwZWNpYWwgPGxpdGVyYWw+dmFyPC9saXRlcmFsPiBmdW5jdGlvbjoKPHByb2dyYW1saXN0aW5nPgp2YXIoaSkgPSBfMTsgLy8gb2sKPC9wcm9ncmFtbGlzdGluZz4KCjwvcGFyYT4KPC9zZWN0aW9uPgoKPHNlY3Rpb24gaWQ9ImxhbWJkYS5sb2dpY2FsX29wZXJhdG9ycyI+Cjx0aXRsZT5Mb2dpY2FsIG9wZXJhdG9yczwvdGl0bGU+Cgo8cGFyYT4KTG9naWNhbCBvcGVyYXRvcnMgb2JleSB0aGUgc2hvcnQtY2lyY3VpdGluZyBldmFsdWF0aW9uIHJ1bGVzLiBGb3IgZXhhbXBsZSwgaW4gdGhlIGZvbGxvd2luZyBjb2RlLCA8bGl0ZXJhbD5pPC9saXRlcmFsPiBpcyBuZXZlciBpbmNyZW1lbnRlZDoKPHByb2dyYW1saXN0aW5nPgpib29sIGZsYWcgPSB0cnVlOyBpbnQgaSA9IDA7CihfMSB8fCArK18yKShmbGFnLCBpKTsKPC9wcm9ncmFtbGlzdGluZz4KPC9wYXJhPgo8L3NlY3Rpb24+Cgo8c2VjdGlvbiBpZD0ibGFtYmRhLmNvbW1hX29wZXJhdG9yIj4KPHRpdGxlPkNvbW1hIG9wZXJhdG9yPC90aXRsZT4KCjxwYXJhPgpDb21tYSBvcGVyYXRvciBpcyB0aGUgPHF1b3RlPnN0YXRlbWVudCBzZXBhcmF0b3I8L3F1b3RlPiBpbiBsYW1iZGEgZXhwcmVzc2lvbnMuIApTaW5jZSBjb21tYSBpcyBhbHNvIHRoZSBzZXBhcmF0b3IgYmV0d2VlbiBhcmd1bWVudHMgaW4gYSBmdW5jdGlvbiBjYWxsLCBleHRyYSBwYXJlbnRoZXNpcyBhcmUgc29tZXRpbWVzIG5lZWRlZDoKCjxwcm9ncmFtbGlzdGluZz4KZm9yX2VhY2goYS5iZWdpbigpLCBhLmVuZCgpLCAoKytfMSwgY291dCAmbHQ7Jmx0OyBfMSkpOwo8L3Byb2dyYW1saXN0aW5nPgoKV2l0aG91dCB0aGUgZXh0cmEgcGFyZW50aGVzaXMgYXJvdW5kIDxsaXRlcmFsPisrXzEsIGNvdXQgJmx0OyZsdDsgXzE8L2xpdGVyYWw+LCB0aGUgY29kZSB3b3VsZCBiZSBpbnRlcnByZXRlZCBhcyBhbiBhdHRlbXB0IHRvIGNhbGwgPGxpdGVyYWw+Zm9yX2VhY2g8L2xpdGVyYWw+IHdpdGggZm91ciBhcmd1bWVudHMuCjwvcGFyYT4KPHBhcmE+ClRoZSBsYW1iZGEgZnVuY3RvciBjcmVhdGVkIGJ5IHRoZSBjb21tYSBvcGVyYXRvciBhZGhlcmVzIHRvIHRoZSBDKysgcnVsZSBvZiBhbHdheXMgZXZhbHVhdGluZyB0aGUgbGVmdCBvcGVyYW5kIGJlZm9yZSB0aGUgcmlnaHQgb25lLgpJbiB0aGUgYWJvdmUgZXhhbXBsZSwgZWFjaCBlbGVtZW50IG9mIDxsaXRlcmFsPmE8L2xpdGVyYWw+IGlzIGZpcnN0IGluY3JlbWVudGVkLCB0aGVuIHdyaXR0ZW4gdG8gdGhlIHN0cmVhbS4KPC9wYXJhPgo8L3NlY3Rpb24+Cgo8c2VjdGlvbiBpZD0ibGFtYmRhLmZ1bmN0aW9uX2NhbGxfb3BlcmF0b3IiPgo8dGl0bGU+RnVuY3Rpb24gY2FsbCBvcGVyYXRvcjwvdGl0bGU+Cgo8cGFyYT4KVGhlIGZ1bmN0aW9uIGNhbGwgb3BlcmF0b3JzIGhhdmUgdGhlIGVmZmVjdCBvZiBldmFsdWF0aW5nIHRoZSBsYW1iZGEKZnVuY3Rvci4gCkNhbGxzIHdpdGggdG9vIGZldyBhcmd1bWVudHMgbGVhZCB0byBhIGNvbXBpbGUgdGltZSBlcnJvci4KPC9wYXJhPgo8L3NlY3Rpb24+Cgo8c2VjdGlvbiBpZD0ibGFtYmRhLm1lbWJlcl9wb2ludGVyX29wZXJhdG9yIj4KPHRpdGxlPk1lbWJlciBwb2ludGVyIG9wZXJhdG9yPC90aXRsZT4KCjxwYXJhPgpUaGUgbWVtYmVyIHBvaW50ZXIgb3BlcmF0b3IgPGxpdGVyYWw+b3BlcmF0b3ItPio8L2xpdGVyYWw+IGNhbiBiZSBvdmVybG9hZGVkIGZyZWVseS4gCkhlbmNlLCBmb3IgdXNlciBkZWZpbmVkIHR5cGVzLCBtZW1iZXIgcG9pbnRlciBvcGVyYXRvciBpcyBubyBzcGVjaWFsIGNhc2UuClRoZSBidWlsdC1pbiBtZWFuaW5nLCBob3dldmVyLCBpcyBhIHNvbWV3aGF0IG1vcmUgY29tcGxpY2F0ZWQgY2FzZS4KVGhlIGJ1aWx0LWluIG1lbWJlciBwb2ludGVyIG9wZXJhdG9yIGlzIGFwcGxpZWQgaWYgdGhlIGxlZnQgYXJndW1lbnQgaXMgYSBwb2ludGVyIHRvIGFuIG9iamVjdCBvZiBzb21lIGNsYXNzIDxsaXRlcmFsPkE8L2xpdGVyYWw+LCBhbmQgdGhlIHJpZ2h0IGhhbmQgYXJndW1lbnQgaXMgYSBwb2ludGVyIHRvIGEgbWVtYmVyIG9mIDxsaXRlcmFsPkE8L2xpdGVyYWw+LCBvciBhIHBvaW50ZXIgdG8gYSBtZW1iZXIgb2YgYSBjbGFzcyBmcm9tIHdoaWNoIDxsaXRlcmFsPkE8L2xpdGVyYWw+IGRlcml2ZXMuCldlIG11c3Qgc2VwYXJhdGUgdHdvIGNhc2VzOgoKPGl0ZW1pemVkbGlzdD4KCjxsaXN0aXRlbT4KPHBhcmE+VGhlIHJpZ2h0IGhhbmQgYXJndW1lbnQgaXMgYSBwb2ludGVyIHRvIGEgZGF0YSBtZW1iZXIuIApJbiB0aGlzIGNhc2UgdGhlIGxhbWJkYSBmdW5jdG9yIHNpbXBseSBwZXJmb3JtcyB0aGUgYXJndW1lbnQgc3Vic3RpdHV0aW9uIGFuZCBjYWxscyB0aGUgYnVpbHQtaW4gbWVtYmVyIHBvaW50ZXIgb3BlcmF0b3IsIHdoaWNoIHJldHVybnMgYSByZWZlcmVuY2UgdG8gdGhlIG1lbWJlciBwb2ludGVkIHRvLiAKRm9yIGV4YW1wbGU6Cjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbc3RydWN0IEEgeyBpbnQgZDsgfTsKQSogYSA9IG5ldyBBKCk7CiAgLi4uCihhIC0+KiAmQTo6ZCk7ICAgICAvLyByZXR1cm5zIGEgcmVmZXJlbmNlIHRvIGEtPmQgCihfMSAtPiogJkE6OmQpKGEpOyAvLyBsaWtld2lzZV1dPgo8L3Byb2dyYW1saXN0aW5nPgo8L3BhcmE+CjwvbGlzdGl0ZW0+Cgo8bGlzdGl0ZW0+CjxwYXJhPgpUaGUgcmlnaHQgaGFuZCBhcmd1bWVudCBpcyBhIHBvaW50ZXIgdG8gYSBtZW1iZXIgZnVuY3Rpb24uCkZvciBhIGJ1aWx0LWluIGNhbGwgbGlrZSB0aGlzLCB0aGUgcmVzdWx0IGlzIGtpbmQgb2YgYSBkZWxheWVkIG1lbWJlciBmdW5jdGlvbiBjYWxsLiAKU3VjaCBhbiBleHByZXNzaW9uIG11c3QgYmUgZm9sbG93ZWQgYnkgYSBmdW5jdGlvbiBhcmd1bWVudCBsaXN0LCB3aXRoIHdoaWNoIHRoZSBkZWxheWVkIG1lbWJlciBmdW5jdGlvbiBjYWxsIGlzIHBlcmZvcm1lZC4KRm9yIGV4YW1wbGU6Cjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbc3RydWN0IEIgeyBpbnQgZm9vKGludCk7IH07CkIqIGIgPSBuZXcgQigpOwogIC4uLgooYiAtPiogJkI6OmZvbykgICAgICAgICAvLyByZXR1cm5zIGEgZGVsYXllZCBjYWxsIHRvIGItPmZvbwogICAgICAgICAgICAgICAgICAgICAgICAvLyBhIGZ1bmN0aW9uIGFyZ3VtZW50IGxpc3QgbXVzdCBmb2xsb3cKKGIgLT4qICZCOjpmb28pKDEpICAgICAgLy8gb2ssIGNhbGxzIGItPmZvbygxKQoKKF8xIC0+KiAmQjo6Zm9vKShiKTsgICAgLy8gcmV0dXJucyBhIGRlbGF5ZWQgY2FsbCB0byBiLT5mb28sIAogICAgICAgICAgICAgICAgICAgICAgICAvLyBubyBlZmZlY3QgYXMgc3VjaAooXzEgLT4qICZCOjpmb28pKGIpKDEpOyAvLyBjYWxscyBiLT5mb28oMSldXT4KPC9wcm9ncmFtbGlzdGluZz4KPC9wYXJhPgo8L2xpc3RpdGVtPgo8L2l0ZW1pemVkbGlzdD4KPC9wYXJhPgo8L3NlY3Rpb24+Cgo8L3NlY3Rpb24+Cgo8c2VjdGlvbiBpZD0ibGFtYmRhLmJpbmRfZXhwcmVzc2lvbnMiPgo8dGl0bGU+QmluZCBleHByZXNzaW9uczwvdGl0bGU+Cgo8cGFyYT4KQmluZCBleHByZXNzaW9ucyBjYW4gaGF2ZSB0d28gZm9ybXM6IAoKPCEtLSBUT0RPOiBzaG91bGRuJ3QgcmVhbGx5IGJlIGVtcGhhc2lzLCBidXQgYSB2YXJpYWJsZSBvciBzb21ldGhpbmctLT4KPHByb2dyYW1saXN0aW5nPgpiaW5kKDxwYXJhbWV0ZXI+dGFyZ2V0LWZ1bmN0aW9uPC9wYXJhbWV0ZXI+LCA8cGFyYW1ldGVyPmJpbmQtYXJndW1lbnQtbGlzdDwvcGFyYW1ldGVyPikKYmluZCg8cGFyYW1ldGVyPnRhcmdldC1tZW1iZXItZnVuY3Rpb248L3BhcmFtZXRlcj4sIDxwYXJhbWV0ZXI+b2JqZWN0LWFyZ3VtZW50PC9wYXJhbWV0ZXI+LCA8cGFyYW1ldGVyPmJpbmQtYXJndW1lbnQtbGlzdDwvcGFyYW1ldGVyPikKPC9wcm9ncmFtbGlzdGluZz4KCkEgYmluZCBleHByZXNzaW9uIGRlbGF5cyB0aGUgY2FsbCBvZiBhIGZ1bmN0aW9uLiAKSWYgdGhpcyA8ZW1waGFzaXM+dGFyZ2V0IGZ1bmN0aW9uPC9lbXBoYXNpcz4gaXMgPGVtcGhhc2lzPm48L2VtcGhhc2lzPi1hcnksIHRoZW4gdGhlIDxsaXRlcmFsPjxlbXBoYXNpcz5iaW5kLWFyZ3VtZW50LWxpc3Q8L2VtcGhhc2lzPjwvbGl0ZXJhbD4gbXVzdCBjb250YWluIDxlbXBoYXNpcz5uPC9lbXBoYXNpcz4gYXJndW1lbnRzIGFzIHdlbGwuCkluIHRoZSBjdXJyZW50IHZlcnNpb24gb2YgdGhlIEJMTCwgPGlubGluZWVxdWF0aW9uPjAgJmx0Oz0gbiAmbHQ7PSA5PC9pbmxpbmVlcXVhdGlvbj4gbXVzdCBob2xkLiAKRm9yIG1lbWJlciBmdW5jdGlvbnMsIHRoZSBudW1iZXIgb2YgYXJndW1lbnRzIG11c3QgYmUgYXQgbW9zdCA8aW5saW5lZXF1YXRpb24+ODwvaW5saW5lZXF1YXRpb24+LCBhcyB0aGUgb2JqZWN0IGFyZ3VtZW50IHRha2VzIG9uZSBhcmd1bWVudCBwb3NpdGlvbi4KCkJhc2ljYWxseSwgdGhlCjxlbXBoYXNpcz48bGl0ZXJhbD5iaW5kLWFyZ3VtZW50LWxpc3Q8L2xpdGVyYWw+PC9lbXBoYXNpcz4gbXVzdCBiZSBhIHZhbGlkIGFyZ3VtZW50IGxpc3QgZm9yIHRoZSB0YXJnZXQgZnVuY3Rpb24sIGV4Y2VwdCB0aGF0IGFueSBhcmd1bWVudCBjYW4gYmUgcmVwbGFjZWQgd2l0aCBhIHBsYWNlaG9sZGVyLCBvciBtb3JlIGdlbmVyYWxseSwgd2l0aCBhIGxhbWJkYSBleHByZXNzaW9uLiAKTm90ZSB0aGF0IGFsc28gdGhlIHRhcmdldCBmdW5jdGlvbiBjYW4gYmUgYSBsYW1iZGEgZXhwcmVzc2lvbi4KClRoZSByZXN1bHQgb2YgYSBiaW5kIGV4cHJlc3Npb24gaXMgZWl0aGVyIGEgbnVsbGFyeSwgdW5hcnksIGJpbmFyeSBvciAzLWFyeSBmdW5jdGlvbiBvYmplY3QgZGVwZW5kaW5nIG9uIHRoZSB1c2Ugb2YgcGxhY2Vob2xkZXJzIGluIHRoZSA8ZW1waGFzaXM+PGxpdGVyYWw+YmluZC1hcmd1bWVudC1saXN0PC9saXRlcmFsPjwvZW1waGFzaXM+IChzZWUgPHhyZWYgbGlua2VuZD0ibGFtYmRhLnBsYWNlaG9sZGVycyIvPikuCjwvcGFyYT4KCjxwYXJhPgpUaGUgcmV0dXJuIHR5cGUgb2YgdGhlIGxhbWJkYSBmdW5jdG9yIGNyZWF0ZWQgYnkgdGhlIGJpbmQgZXhwcmVzc2lvbiBjYW4gYmUgZ2l2ZW4gYXMgYW4gZXhwbGljaXRseSBzcGVjaWZpZWQgdGVtcGxhdGUgcGFyYW1ldGVyLCBhcyBpbiB0aGUgZm9sbG93aW5nIGV4YW1wbGU6Cjxwcm9ncmFtbGlzdGluZz4KYmluZCZsdDs8ZW1waGFzaXM+UkVUPC9lbXBoYXNpcz4mZ3Q7KDxlbXBoYXNpcz50YXJnZXQtZnVuY3Rpb248L2VtcGhhc2lzPiwgPGVtcGhhc2lzPmJpbmQtYXJndW1lbnQtbGlzdDwvZW1waGFzaXM+KQo8L3Byb2dyYW1saXN0aW5nPgpUaGlzIGlzIG9ubHkgbmVjZXNzYXJ5IGlmIHRoZSByZXR1cm4gdHlwZSBvZiB0aGUgdGFyZ2V0IGZ1bmN0aW9uIGNhbm5vdCBiZSBkZWR1Y2VkLgo8L3BhcmE+Cgo8cGFyYT4KVGhlIGZvbGxvd2luZyBzZWN0aW9ucyBkZXNjcmliZSB0aGUgZGlmZmVyZW50IHR5cGVzIG9mIGJpbmQgZXhwcmVzc2lvbnMuCjwvcGFyYT4KCjxzZWN0aW9uIGlkPSJsYW1iZGEuZnVuY3Rpb25fcG9pbnRlcnNfYXNfdGFyZ2V0cyI+Cjx0aXRsZT5GdW5jdGlvbiBwb2ludGVycyBvciByZWZlcmVuY2VzIGFzIHRhcmdldHM8L3RpdGxlPgoKPHBhcmE+VGhlIHRhcmdldCBmdW5jdGlvbiBjYW4gYmUgYSBwb2ludGVyIG9yIGEgcmVmZXJlbmNlIHRvIGEgZnVuY3Rpb24gYW5kIGl0IGNhbiBiZSBlaXRoZXIgYm91bmQgb3IgdW5ib3VuZC4gRm9yIGV4YW1wbGU6Cjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbWCBmb28oQSwgQiwgQyk7IEEgYTsgQiBiOyBDIGM7CmJpbmQoZm9vLCBfMSwgXzIsIGMpKGEsIGIpOwpiaW5kKCZmb28sIF8xLCBfMiwgYykoYSwgYik7CmJpbmQoXzEsIGEsIGIsIGMpKGZvbyk7XV0+CjwvcHJvZ3JhbWxpc3Rpbmc+CiAKVGhlIHJldHVybiB0eXBlIGRlZHVjdGlvbiBhbHdheXMgc3VjY2VlZHMgd2l0aCB0aGlzIHR5cGUgb2YgYmluZCBleHByZXNzaW9ucy4gCjwvcGFyYT4KCjxwYXJhPgpOb3RlLCB0aGF0IGluIEMrKyBpdCBpcyBwb3NzaWJsZSB0byB0YWtlIHRoZSBhZGRyZXNzIG9mIGFuIG92ZXJsb2FkZWQgZnVuY3Rpb24gb25seSBpZiB0aGUgYWRkcmVzcyBpcyBhc3NpZ25lZCB0bywgb3IgdXNlZCBhcyBhbiBpbml0aWFsaXplciBvZiwgYSB2YXJpYWJsZSwgdGhlIHR5cGUgb2Ygd2hpY2ggc29sdmVzIHRoZSBhbWliaWd1aXR5LCBvciBpZiBhbiBleHBsaWNpdCBjYXN0IGV4cHJlc3Npb24gaXMgdXNlZC4KVGhpcyBtZWFucyB0aGF0IG92ZXJsb2FkZWQgZnVuY3Rpb25zIGNhbm5vdCBiZSB1c2VkIGluIGJpbmQgZXhwcmVzc2lvbnMgZGlyZWN0bHksIGUuZy46Cjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbdm9pZCBmb28oaW50KTsKdm9pZCBmb28oZmxvYXQpOwppbnQgaTsgCiAgLi4uCmJpbmQoJmZvbywgXzEpKGkpOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyBlcnJvciAKICAuLi4Kdm9pZCAoKnBmMSkoaW50KSA9ICZmb287CmJpbmQocGYxLCBfMSkoaSk7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyBvawpiaW5kKHN0YXRpY19jYXN0PHZvaWQoKikoaW50KT4oJmZvbyksIF8xKShpKTsgLy8gb2tdXT4KPC9wcm9ncmFtbGlzdGluZz4KPC9wYXJhPgo8L3NlY3Rpb24+Cgo8c2VjdGlvbiBpZD0ibWVtYmVyX2Z1bmN0aW9uc19hc190YXJnZXRzIj4KPHRpdGxlPk1lbWJlciBmdW5jdGlvbnMgYXMgdGFyZ2V0czwvdGl0bGU+Cgo8cGFyYT4KVGhlIHN5bnRheCBmb3IgdXNpbmcgcG9pbnRlcnMgdG8gbWVtYmVyIGZ1bmN0aW9uIGluIGJpbmQgZXhwcmVzc2lvbiBpczoKPHByb2dyYW1saXN0aW5nPgpiaW5kKDxwYXJhbWV0ZXI+dGFyZ2V0LW1lbWJlci1mdW5jdGlvbjwvcGFyYW1ldGVyPiwgPHBhcmFtZXRlcj5vYmplY3QtYXJndW1lbnQ8L3BhcmFtZXRlcj4sIDxwYXJhbWV0ZXI+YmluZC1hcmd1bWVudC1saXN0PC9wYXJhbWV0ZXI+KQo8L3Byb2dyYW1saXN0aW5nPgoKVGhlIG9iamVjdCBhcmd1bWVudCBjYW4gYmUgYSByZWZlcmVuY2Ugb3IgcG9pbnRlciB0byB0aGUgb2JqZWN0LCB0aGUgQkxMIHN1cHBvcnRzIGJvdGggY2FzZXMgd2l0aCBhIHVuaWZvcm0gaW50ZXJmYWNlOiAKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbYm9vbCBBOjpmb28oaW50KSBjb25zdDsgCkEgYTsKdmVjdG9yPGludD4gaW50czsgCiAgLi4uCmZpbmRfaWYoaW50cy5iZWdpbigpLCBpbnRzLmVuZCgpLCBiaW5kKCZBOjpmb28sIGEsIF8xKSk7IApmaW5kX2lmKGludHMuYmVnaW4oKSwgaW50cy5lbmQoKSwgYmluZCgmQTo6Zm9vLCAmYSwgXzEpKTtdXT4KPC9wcm9ncmFtbGlzdGluZz4KClNpbWlsYXJseSwgaWYgdGhlIG9iamVjdCBhcmd1bWVudCBpcyB1bmJvdW5kLCB0aGUgcmVzdWx0aW5nIGxhbWJkYSBmdW5jdG9yIGNhbiBiZSBjYWxsZWQgYm90aCB2aWEgYSBwb2ludGVyIG9yIGEgcmVmZXJlbmNlOgoKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVtib29sIEE6OmZvbyhpbnQpOyAKbGlzdDxBPiByZWZzOyAKbGlzdDxBKj4gcG9pbnRlcnM7IAogIC4uLgpmaW5kX2lmKHJlZnMuYmVnaW4oKSwgcmVmcy5lbmQoKSwgYmluZCgmQTo6Zm9vLCBfMSwgMSkpOyAKZmluZF9pZihwb2ludGVycy5iZWdpbigpLCBwb2ludGVycy5lbmQoKSwgYmluZCgmQTo6Zm9vLCBfMSwgMSkpO11dPgo8L3Byb2dyYW1saXN0aW5nPgoKPC9wYXJhPgoKPCEtLSVUaGUgZXhhY3QgcnVsZXMgZm9yIHRoZSBvYmplY3QgYXJndW1lbnQgKHdoZXRoZXIgaXQgaXMgYm91bmQsIG9yIHN1cHBsaWVkIGluIHRoZSBsYW1iZGEgZnVuY3Rpb24gaW52b2N0aW9uKSBhcmUgYXMgZm9sbG93czoKJUlmIHRoZSB0YXJnZXQgZnVuY3Rpb24gaXMgYSBwb2ludGVyIHRvIGEgbWVtYmVyIGZ1bmN0aW9uIG9mIHNvbWUgY2xhc3MgXHNuaXB7QX0sIHRoZW4gdGhlIG9iamVjdCBhcmd1bWVudCBtdXN0IGJlIGFuIGV4cHJlc3Npb24gb2YgdHlwZSBcc25pcHtCfSwgd2hlcmUgZWl0aGVyCiVcYmVnaW57aXRlbWl6ZX0KJVxpdGVtIFxzbmlwe0J9ID0gXHNuaXB7QX0gb3IgdGhlcmUgaXMgYW4gaW1wbGljaXQgY29udmVyc2lvbiBmcm9tIFxzbmlwe0J9IHRvIFxzbmlwe0F9LgolXGl0ZW0gXHNuaXB7Qn0gPSBcc25pcHtBKn0uCiVcaXRlbSBcc25pcHtCfSA9IFxzbmlwe0MqfSwgd2hlcmUgXHNuaXB7Q30gaXMgYW55IGNsYXNzIGRlcml2ZWQgZm9ybSBcc25pcHtBfS4KJVxlbmR7aXRlbWl6ZX0KJUZvciBleGFtcGxlOgolXGJlZ2lue2FsbHR0fQolc3RydWN0IEEgXHsKJSAgdmlydHVhbCB2b2lkIGYoKTsKJSAgdm9pZCBmYygpIGNvbnN0OwolXH07CiUKJXN0cnVjdCBCIDogcHVibGljIEEgXHsgCiUgIHZpcnR1YWwgdm9pZCBmKCk7IAolXH07CiUKJXN0cnVjdCBDIFx7CiUgIG9wZXJhdG9yIEEgY29uc3QoKSBceyByZXR1cm4gQSgpOyBcfQolXH07CiUKJSBBIGE7IEIgYjsgQyBjOwolICAuLi4KJSBiaW5kKCZBOjpmLCBhKSgpOyAKJSBiaW5kKCZBOjpmLCBiKSgpOyAvLyBjYWxscyBCOjpmCiUgYmluZCgmQTo6ZmMsIGMpKCk7IAolCiUgYmluZCgmQTo6ZiwgJmEpKCk7CiUgYmluZCgmQTo6ZiwgJmIpKCk7IC8vIGNhbGxzIEI6OmYKJSBiaW5kKCZBOjpmLCAmYykoKTsgLy8gZXJyb3I6IG5vIGNvbnZlcnNpb24gZnJvbSBDKiBcKFxyaWdodGFycm93XCkgQSwgCiVcZW5ke2FsbHR0fQotLT4KCjxwYXJhPgpFdmVuIHRob3VnaCB0aGUgaW50ZXJmYWNlcyBhcmUgdGhlIHNhbWUsIHRoZXJlIGFyZSBpbXBvcnRhbnQgc2VtYW50aWMgZGlmZmVyZW5jZXMgYmV0d2VlbiB1c2luZyBhIHBvaW50ZXIgb3IgYSByZWZlcmVuY2UgYXMgdGhlIG9iamVjdCBhcmd1bWVudC4KVGhlIGRpZmZlcmVuY2VzIHN0ZW0gZnJvbSB0aGUgd2F5IDxsaXRlcmFsPmJpbmQ8L2xpdGVyYWw+LWZ1bmN0aW9ucyB0YWtlIHRoZWlyIHBhcmFtZXRlcnMsIGFuZCBob3cgdGhlIGJvdW5kIHBhcmFtZXRlcnMgYXJlIHN0b3JlZCB3aXRoaW4gdGhlIGxhbWJkYSBmdW5jdG9yLgpUaGUgb2JqZWN0IGFyZ3VtZW50IGhhcyB0aGUgc2FtZSBwYXJhbWV0ZXIgcGFzc2luZyBhbmQgc3RvcmluZyBtZWNoYW5pc20gYXMgYW55IG90aGVyIGJpbmQgYXJndW1lbnQgc2xvdCAoc2VlIDx4cmVmIGxpbmtlbmQ9ImxhbWJkYS5zdG9yaW5nX2JvdW5kX2FyZ3VtZW50cyIvPik7IGl0IGlzIHBhc3NlZCBhcyBhIGNvbnN0IHJlZmVyZW5jZSBhbmQgc3RvcmVkIGFzIGEgY29uc3QgY29weSBpbiB0aGUgbGFtYmRhIGZ1bmN0b3IuClRoaXMgY3JlYXRlcyBzb21lIGFzeW1tZXRyeSBiZXR3ZWVuIHRoZSBsYW1iZGEgZnVuY3RvciBhbmQgdGhlIG9yaWdpbmFsIG1lbWJlciBmdW5jdGlvbiwgYW5kIGJldHdlZW4gc2VlbWluZ2x5IHNpbWlsYXIgbGFtYmRhIGZ1bmN0b3JzLiBGb3IgZXhhbXBsZToKPHByb2dyYW1saXN0aW5nPgpjbGFzcyBBIHsKICBpbnQgaTsgbXV0YWJsZSBpbnQgajsKcHVibGljOgoKICBBKGludCBpaSwgaW50IGpqKSA6IGkoaWkpLCBqKGpqKSB7fTsKICB2b2lkIHNldF9pKGludCB4KSB7IGkgPSB4OyB9OyAKICB2b2lkIHNldF9qKGludCB4KSBjb25zdCB7IGogPSB4OyB9OyAKfTsKPC9wcm9ncmFtbGlzdGluZz4KCldoZW4gYSBwb2ludGVyIGlzIHVzZWQsIHRoZSBiZWhhdmlvciBpcyB3aGF0IHRoZSBwcm9ncmFtbWVyIG1pZ2h0IGV4cGVjdDoKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbQSBhKDAsMCk7IGludCBrID0gMTsKYmluZCgmQTo6c2V0X2ksICZhLCBfMSkoayk7IC8vIGEuaSA9PSAxCmJpbmQoJkE6OnNldF9qLCAmYSwgXzEpKGspOyAvLyBhLmogPT0gMV1dPgo8L3Byb2dyYW1saXN0aW5nPgoKRXZlbiB0aG91Z2ggYSBjb25zdCBjb3B5IG9mIHRoZSBvYmplY3QgYXJndW1lbnQgaXMgc3RvcmVkLCB0aGUgb3JpZ2luYWwgb2JqZWN0IDxsaXRlcmFsPmE8L2xpdGVyYWw+IGlzIHN0aWxsIG1vZGlmaWVkLgpUaGlzIGlzIHNpbmNlIHRoZSBvYmplY3QgYXJndW1lbnQgaXMgYSBwb2ludGVyLCBhbmQgdGhlIHBvaW50ZXIgaXMgY29waWVkLCBub3QgdGhlIG9iamVjdCBpdCBwb2ludHMgdG8uCldoZW4gd2UgdXNlIGEgcmVmZXJlbmNlLCB0aGUgYmVoYXZpb3VyIGlzIGRpZmZlcmVudDoKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbQSBhKDAsMCk7IGludCBrID0gMTsKYmluZCgmQTo6c2V0X2ksIGEsIF8xKShrKTsgLy8gZXJyb3I7IGEgY29uc3QgY29weSBvZiBhIGlzIHN0b3JlZC4gCiAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIENhbm5vdCBjYWxsIGEgbm9uLWNvbnN0IGZ1bmN0aW9uIHNldF9pCmJpbmQoJkE6OnNldF9qLCBhLCBfMSkoayk7IC8vIGEuaiA9PSAwLCBhcyBhIGNvcHkgb2YgYSBpcyBtb2RpZmllZF1dPgo8L3Byb2dyYW1saXN0aW5nPgo8L3BhcmE+Cgo8cGFyYT4KVG8gcHJldmVudCB0aGUgY29weWluZyBmcm9tIHRha2luZyBwbGFjZSwgb25lIGNhbiB1c2UgdGhlIDxsaXRlcmFsPnJlZjwvbGl0ZXJhbD4gb3IgPGxpdGVyYWw+Y3JlZjwvbGl0ZXJhbD4gd3JhcHBlcnMgKDxsaXRlcmFsPnZhcjwvbGl0ZXJhbD4gYW5kIDxsaXRlcmFsPmNvbnN0YW50X3JlZjwvbGl0ZXJhbD4gd291bGQgZG8gYXMgd2VsbCk6Cjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbYmluZCgmQTo6c2V0X2ksIHJlZihhKSwgXzEpKGspOyAvLyBhLmogPT0gMQpiaW5kKCZBOjpzZXRfaiwgY3JlZihhKSwgXzEpKGspOyAvLyBhLmogPT0gMV1dPgo8L3Byb2dyYW1saXN0aW5nPgo8L3BhcmE+Cgo8cGFyYT5Ob3RlIHRoYXQgdGhlIHByZWNlZGluZyBkaXNjdXNzaW9uIGlzIHJlbGV2YW50IG9ubHkgZm9yIGJvdW5kIGFyZ3VtZW50cy4gCklmIHRoZSBvYmplY3QgYXJndW1lbnQgaXMgdW5ib3VuZCwgdGhlIHBhcmFtZXRlciBwYXNzaW5nIG1vZGUgaXMgYWx3YXlzIGJ5IHJlZmVyZW5jZS4gCkhlbmNlLCB0aGUgYXJndW1lbnQgPGxpdGVyYWw+YTwvbGl0ZXJhbD4gaXMgbm90IGNvcGllZCBpbiB0aGUgY2FsbHMgdG8gdGhlIHR3byBsYW1iZGEgZnVuY3RvcnMgYmVsb3c6Cjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbQSBhKDAsMCk7CmJpbmQoJkE6OnNldF9pLCBfMSwgMSkoYSk7IC8vIGEuaSA9PSAxCmJpbmQoJkE6OnNldF9qLCBfMSwgMSkoYSk7IC8vIGEuaiA9PSAxXV0+CjwvcHJvZ3JhbWxpc3Rpbmc+CjwvcGFyYT4KPC9zZWN0aW9uPgoKPHNlY3Rpb24gaWQ9ImxhbWJkYS5tZW1iZXJzX3ZhcmlhYmxlc19hc190YXJnZXRzIj4KPHRpdGxlPk1lbWJlciB2YXJpYWJsZXMgYXMgdGFyZ2V0czwvdGl0bGU+Cgo8cGFyYT4KQSBwb2ludGVyIHRvIGEgbWVtYmVyIHZhcmlhYmxlIGlzIG5vdCByZWFsbHkgYSBmdW5jdGlvbiwgYnV0IAp0aGUgZmlyc3QgYXJndW1lbnQgdG8gdGhlIDxsaXRlcmFsPmJpbmQ8L2xpdGVyYWw+IGZ1bmN0aW9uIGNhbiBuZXZlcnRoZWxlc3MKYmUgYSBwb2ludGVyIHRvIGEgbWVtYmVyIHZhcmlhYmxlLgpJbnZva2luZyBzdWNoIGEgYmluZCBleHByZXNzaW9uIHJldHVybnMgYSByZWZlcmVuY2UgdG8gdGhlIGRhdGEgbWVtYmVyLgpGb3IgZXhhbXBsZToKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbc3RydWN0IEEgeyBpbnQgZGF0YTsgfTsKQSBhOwpiaW5kKCZBOjpkYXRhLCBfMSkoYSkgPSAxOyAgICAgLy8gYS5kYXRhID09IDFdXT4KPC9wcm9ncmFtbGlzdGluZz4KClRoZSBjdi1xdWFsaWZpZXJzIG9mIHRoZSBvYmplY3Qgd2hvc2UgbWVtYmVyIGlzIGFjY2Vzc2VkIGFyZSByZXNwZWN0ZWQuCkZvciBleGFtcGxlLCB0aGUgZm9sbG93aW5nIHRyaWVzIHRvIHdyaXRlIGludG8gYSBjb25zdCBsb2NhdGlvbjoKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVtjb25zdCBBIGNhID0gYTsKYmluZCgmQTo6ZGF0YSwgXzEpKGNhKSA9IDE7ICAgICAvLyBlcnJvcl1dPgo8L3Byb2dyYW1saXN0aW5nPgoKPC9wYXJhPgo8L3NlY3Rpb24+Cgo8c2VjdGlvbiBpZD0ibGFtYmRhLmZ1bmN0aW9uX29iamVjdHNfYXNfdGFyZ2V0cyI+Cjx0aXRsZT5GdW5jdGlvbiBvYmplY3RzIGFzIHRhcmdldHM8L3RpdGxlPgoKPHBhcmE+CgpGdW5jdGlvbiBvYmplY3RzLCB0aGF0IGlzLCBjbGFzcyBvYmplY3RzIHdoaWNoIGhhdmUgdGhlIGZ1bmN0aW9uIGNhbGwgCm9wZXJhdG9yIGRlZmluZWQsIGNhbiBiZSB1c2VkIGFzIHRhcmdldCBmdW5jdGlvbnMuIAoKSW4gZ2VuZXJhbCwgQkxMIGNhbm5vdCBkZWR1Y2UgdGhlIHJldHVybiB0eXBlIG9mIGFuIGFyYml0cmFyeSBmdW5jdGlvbiBvYmplY3QuIAoKSG93ZXZlciwgdGhlcmUgYXJlIHR3byBtZXRob2RzIGZvciBnaXZpbmcgQkxMIHRoaXMgY2FwYWJpbGl0eSBmb3IgYSBjZXJ0YWluIApmdW5jdGlvbiBvYmplY3QgY2xhc3MuCgo8L3BhcmE+Cgo8c2ltcGxlc2VjdD4KCjx0aXRsZT5UaGUgcmVzdWx0X3R5cGUgdHlwZWRlZjwvdGl0bGU+Cgo8cGFyYT4KClRoZSBCTEwgc3VwcG9ydHMgdGhlIHN0YW5kYXJkIGxpYnJhcnkgY29udmVudGlvbiBvZiBkZWNsYXJpbmcgdGhlIHJldHVybiB0eXBlCm9mIGEgZnVuY3Rpb24gb2JqZWN0IHdpdGggYSBtZW1iZXIgdHlwZWRlZiBuYW1lZCA8bGl0ZXJhbD5yZXN1bHRfdHlwZTwvbGl0ZXJhbD4gaW4gdGhlCmZ1bmN0aW9uIG9iamVjdCBjbGFzcy4KCkhlcmUgaXMgYSBzaW1wbGUgZXhhbXBsZToKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVtzdHJ1Y3QgQSB7CiAgdHlwZWRlZiBCIHJlc3VsdF90eXBlOwogIEIgb3BlcmF0b3IoKShYLCBZLCBaKTsgCn07XV0+CjwvcHJvZ3JhbWxpc3Rpbmc+CgpJZiBhIGZ1bmN0aW9uIG9iamVjdCBkb2VzIG5vdCBkZWZpbmUgYSA8bGl0ZXJhbD5yZXN1bHRfdHlwZTwvbGl0ZXJhbD4gdHlwZWRlZiwgCnRoZSBtZXRob2QgZGVzY3JpYmVkIGJlbG93ICg8bGl0ZXJhbD5zaWc8L2xpdGVyYWw+IHRlbXBsYXRlKSAKaXMgYXR0ZW1wdGVkIHRvIHJlc29sdmUgdGhlIHJldHVybiB0eXBlIG9mIHRoZQpmdW5jdGlvbiBvYmplY3QuIElmIGEgZnVuY3Rpb24gb2JqZWN0IGRlZmluZXMgYm90aCA8bGl0ZXJhbD5yZXN1bHRfdHlwZTwvbGl0ZXJhbD4KYW5kIDxsaXRlcmFsPnNpZzwvbGl0ZXJhbD4sIDxsaXRlcmFsPnJlc3VsdF90eXBlPC9saXRlcmFsPiB0YWtlcyBwcmVjZWRlbmNlLgoKPC9wYXJhPgoKPC9zaW1wbGVzZWN0PgoKPHNpbXBsZXNlY3Q+Cgo8dGl0bGU+VGhlIHNpZyB0ZW1wbGF0ZTwvdGl0bGU+Cgo8cGFyYT4KQW5vdGhlciBtZWNoYW5pc20gdGhhdCBtYWtlIEJMTCBhd2FyZSBvZiB0aGUgcmV0dXJuIHR5cGUocykgb2YgYSBmdW5jdGlvbiBvYmplY3QgaXMgZGVmaW5pbmcKbWVtYmVyIHRlbXBsYXRlIHN0cnVjdCAKPGxpdGVyYWw+PCFbQ0RBVEFbc2lnPEFyZ3M+XV0+PC9saXRlcmFsPiB3aXRoIGEgdHlwZWRlZiAKPGxpdGVyYWw+dHlwZTwvbGl0ZXJhbD4gdGhhdCBzcGVjaWZpZXMgdGhlIHJldHVybiB0eXBlLgoKSGVyZSBpcyBhIHNpbXBsZSBleGFtcGxlOgo8cHJvZ3JhbWxpc3Rpbmc+CjwhW0NEQVRBW3N0cnVjdCBBIHsKICB0ZW1wbGF0ZSA8Y2xhc3MgQXJncz4gc3RydWN0IHNpZyB7IHR5cGVkZWYgQiB0eXBlOyB9CiAgQiBvcGVyYXRvcigpKFgsIFksIFopOyAKfTtdXT4KPC9wcm9ncmFtbGlzdGluZz4KClRoZSB0ZW1wbGF0ZSBhcmd1bWVudCA8bGl0ZXJhbD5BcmdzPC9saXRlcmFsPiBpcyBhIAo8bGl0ZXJhbD50dXBsZTwvbGl0ZXJhbD4gKG9yIG1vcmUgcHJlY2lzZWx5IGEgPGxpdGVyYWw+Y29uczwvbGl0ZXJhbD4gbGlzdCkgCnR5cGUgPHhyZWYgbGlua2VuZD0iY2l0OmJvb3N0Ojp0dXBsZSIvPiwgd2hlcmUgdGhlIGZpcnN0IGVsZW1lbnQgCmlzIHRoZSBmdW5jdGlvbiAKb2JqZWN0IHR5cGUgaXRzZWxmLCBhbmQgdGhlIHJlbWFpbmluZyBlbGVtZW50cyBhcmUgdGhlIHR5cGVzIG9mIAp0aGUgYXJndW1lbnRzLCB3aXRoIHdoaWNoIHRoZSBmdW5jdGlvbiBvYmplY3QgaXMgYmVpbmcgY2FsbGVkLgoKVGhpcyBtYXkgc2VlbSBvdmVybHkgY29tcGxleCBjb21wYXJlZCB0byBkZWZpbmluZyB0aGUgPGxpdGVyYWw+cmVzdWx0X3R5cGU8L2xpdGVyYWw+IHR5cGVkZWYuCkhvd3ZlciwgdGhlcmUgYXJlIHR3byBzaWduaWZpY2FudCByZXN0cmljdGlvbnMgd2l0aCB1c2luZyBqdXN0IGEgc2ltcGxlCnR5cGVkZWYgdG8gZXhwcmVzcyB0aGUgcmV0dXJuIHR5cGU6CjxvcmRlcmVkbGlzdD4KPGxpc3RpdGVtPgo8cGFyYT4KSWYgdGhlIGZ1bmN0aW9uIG9iamVjdCBkZWZpbmVzIHNldmVyYWwgZnVuY3Rpb24gY2FsbCBvcGVyYXRvcnMsIHRoZXJlIGlzIG5vIHdheSB0byBzcGVjaWZ5IGRpZmZlcmVudCByZXN1bHQgdHlwZXMgZm9yIHRoZW0uCjwvcGFyYT4KPC9saXN0aXRlbT4KPGxpc3RpdGVtPgo8cGFyYT4KSWYgdGhlIGZ1bmN0aW9uIGNhbGwgb3BlcmF0b3IgaXMgYSB0ZW1wbGF0ZSwgdGhlIHJlc3VsdCB0eXBlIG1heSAKZGVwZW5kIG9uIHRoZSB0ZW1wbGF0ZSBwYXJhbWV0ZXJzLiAKSGVuY2UsIHRoZSB0eXBlZGVmIG91Z2h0IHRvIGJlIGEgdGVtcGxhdGUgdG9vLCB3aGljaCB0aGUgQysrIGxhbmd1YWdlIApkb2VzIG5vdCBzdXBwb3J0Lgo8L3BhcmE+CjwvbGlzdGl0ZW0+Cjwvb3JkZXJlZGxpc3Q+CgpUaGUgZm9sbG93aW5nIGNvZGUgc2hvd3MgYW4gZXhhbXBsZSwgd2hlcmUgdGhlIHJldHVybiB0eXBlIGRlcGVuZHMgb24gdGhlIHR5cGUKb2Ygb25lIG9mIHRoZSBhcmd1bWVudHMsIGFuZCBob3cgdGhhdCBkZXBlbmRlbmN5IGNhbiBiZSBleHByZXNzZWQgd2l0aCB0aGUKPGxpdGVyYWw+c2lnPC9saXRlcmFsPiB0ZW1wbGF0ZToKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbc3RydWN0IEEgewoKICAvLyB0aGUgcmV0dXJuIHR5cGUgZXF1YWxzIHRoZSB0aGlyZCBhcmd1bWVudCB0eXBlOgogIHRlbXBsYXRlPGNsYXNzIFQxLCBjbGFzcyBUMiwgY2xhc3MgVDM+CiAgVDMgb3BlcmF0b3IoKShjb25zdCBUMSYgdDEsIGNvbnN0IFQyJiB0MiwgY29uc3QgVDMmIHQzKSBjb25zdDsKCiAgdGVtcGxhdGUgPGNsYXNzIEFyZ3M+IAogIGNsYXNzIHNpZyB7CiAgICAvLyBnZXQgdGhlIHRoaXJkIGFyZ3VtZW50IHR5cGUgKDR0aCBlbGVtZW50KQogICAgdHlwZWRlZiB0eXBlbmFtZSAKICAgICAgYm9vc3Q6OnR1cGxlczo6ZWxlbWVudDwzLCBBcmdzPjo6dHlwZSBUMzsKICBwdWJsaWM6CiAgICB0eXBlZGVmIHR5cGVuYW1lIAogICAgICBib29zdDo6cmVtb3ZlX2N2PFQzPjo6dHlwZSB0eXBlOwogIH07Cn07XV0+CjwvcHJvZ3JhbWxpc3Rpbmc+CgoKVGhlIGVsZW1lbnRzIG9mIHRoZSA8bGl0ZXJhbD5BcmdzPC9saXRlcmFsPiB0dXBsZSBhcmUgYWx3YXlzIApub24tcmVmZXJlbmNlIHR5cGVzLgoKTW9yZW92ZXIsIHRoZSBlbGVtZW50IHR5cGVzIGNhbiBoYXZlIGEgY29uc3Qgb3Igdm9sYXRpbGUgcXVhbGlmaWVyCihqb2ludGx5IHJlZmVycmVkIHRvIGFzIDxlbXBoYXNpcz5jdi1xdWFsaWZpZXJzPC9lbXBoYXNpcz4pLCBvciBib3RoLgpUaGlzIGlzIHNpbmNlIHRoZSBjdi1xdWFsaWZpZXJzIGluIHRoZSBhcmd1bWVudHMgY2FuIGFmZmVjdCB0aGUgcmV0dXJuIHR5cGUuClRoZSByZWFzb24gZm9yIGluY2x1ZGluZyB0aGUgcG90ZW50aWFsbHkgY3YtcXVhbGlmaWVkIGZ1bmN0aW9uIG9iamVjdCAKdHlwZSBpdHNlbGYgaW50byB0aGUgPGxpdGVyYWw+QXJnczwvbGl0ZXJhbD4gdHVwbGUsIGlzIHRoYXQgdGhlIGZ1bmN0aW9uCm9iamVjdCBjbGFzcyBjYW4gY29udGFpbiBib3RoIGNvbnN0IGFuZCBub24tY29uc3QgKG9yIHZvbGF0aWxlLCBldmVuCmNvbnN0IHZvbGF0aWxlKSBmdW5jdGlvbiBjYWxsIG9wZXJhdG9ycywgYW5kIHRoZXkgY2FuIGVhY2ggaGF2ZSBhIGRpZmZlcmVudApyZXR1cm4gdHlwZS4KPC9wYXJhPgoKPHBhcmE+ClRoZSA8bGl0ZXJhbD5zaWc8L2xpdGVyYWw+IHRlbXBsYXRlIGNhbiBiZSBzZWVuIGFzIGEgCjxlbXBoYXNpcz5tZXRhLWZ1bmN0aW9uPC9lbXBoYXNpcz4gdGhhdCBtYXBzIHRoZSBhcmd1bWVudCB0eXBlIHR1cGxlIHRvIAp0aGUgcmVzdWx0IHR5cGUgb2YgdGhlIGNhbGwgbWFkZSB3aXRoIGFyZ3VtZW50cyBvZiB0aGUgdHlwZXMgaW4gdGhlIHR1cGxlLgoKQXMgdGhlIGV4YW1wbGUgYWJvdmUgZGVtb25zdHJhdGVzLCB0aGUgdGVtcGxhdGUgY2FuIGVuZCB1cCBiZWluZyBzb21ld2hhdCAKY29tcGxleC4KVHlwaWNhbCB0YXNrcyB0byBiZSBwZXJmb3JtZWQgYXJlIHRoZSBleHRyYWN0aW9uIG9mIHRoZSByZWxldmFudCB0eXBlcyAKZnJvbSB0aGUgdHVwbGUsIHJlbW92aW5nIGN2LXF1YWxpZmllcnMgZXRjLgpTZWUgdGhlIEJvb3N0IHR5cGVfdHJhaXRzIDx4cmVmIGxpbmtlbmQ9ImNpdDpib29zdDo6dHlwZV90cmFpdHMiLz4gYW5kClR1cGxlIDx4cmVmIGxpbmtlbmQ9ImNpdDpib29zdDo6dHlwZV90cmFpdHMiLz4gbGlicmFyaWVzIApmb3IgdG9vbHMgdGhhdCBjYW4gYWlkIGluIHRoZXNlIHRhc2tzLgpUaGUgPGxpdGVyYWw+c2lnPC9saXRlcmFsPiB0ZW1wbGF0ZXMgYXJlIGEgcmVmaW5lZCB2ZXJzaW9uIG9mIGEgc2ltaWxhcgptZWNoYW5pc20gZmlyc3QgaW50cm9kdWNlZCBpbiB0aGUgRkMrKyBsaWJyYXJ5ICAKPHhyZWYgbGlua2VuZD0iY2l0OmZjKysiLz4uCjwvcGFyYT4KCjwvc2ltcGxlc2VjdD4KCjwvc2VjdGlvbj4KCgoKPC9zZWN0aW9uPgoKPHNlY3Rpb24gaWQ9ImxhbWJkYS5vdmVycmlkaW5nX2RlZHVjZWRfcmV0dXJuX3R5cGUiPgo8dGl0bGU+T3ZlcnJpZGluZyB0aGUgZGVkdWNlZCByZXR1cm4gdHlwZTwvdGl0bGU+Cgo8cGFyYT4KVGhlIHJldHVybiB0eXBlIGRlZHVjdGlvbiBzeXN0ZW0gbWF5IG5vdCBiZSBhYmxlIHRvIGRlZHVjZSB0aGUgcmV0dXJuIHR5cGVzIG9mIHNvbWUgdXNlciBkZWZpbmVkIG9wZXJhdG9ycyBvciBiaW5kIGV4cHJlc3Npb25zIHdpdGggY2xhc3Mgb2JqZWN0cy4KPCEtLSAoc2VlIHRoZSBleGFtcGxlIGluIDx4cmVmIGxpbmtlbmQ9ImxhbWJkYS5wYXJhbWV0ZXJfYW5kX3JldHVybl90eXBlcyIvPikuLS0+CkEgc3BlY2lhbCBsYW1iZGEgZXhwcmVzc2lvbiB0eXBlIGlzIHByb3ZpZGVkIGZvciBzdGF0aW5nIHRoZSByZXR1cm4gdHlwZSBleHBsaWNpdGx5IGFuZCBvdmVycmlkaW5nIHRoZSBkZWR1Y3Rpb24gc3lzdGVtLiAKVG8gc3RhdGUgdGhhdCB0aGUgcmV0dXJuIHR5cGUgb2YgdGhlIGxhbWJkYSBmdW5jdG9yIGRlZmluZWQgYnkgdGhlIGxhbWJkYSBleHByZXNzaW9uIDxsaXRlcmFsPmU8L2xpdGVyYWw+IGlzIDxsaXRlcmFsPlQ8L2xpdGVyYWw+LCB5b3UgY2FuIHdyaXRlOgoKPHByb2dyYW1saXN0aW5nPjwhW0NEQVRBW3JldDxUPihlKTtdXT48L3Byb2dyYW1saXN0aW5nPgoKVGhlIGVmZmVjdCBpcyB0aGF0IHRoZSByZXR1cm4gdHlwZSBkZWR1Y3Rpb24gaXMgbm90IHBlcmZvcm1lZCBmb3IgdGhlIGxhbWJkYSBleHByZXNzaW9uIDxsaXRlcmFsPmU8L2xpdGVyYWw+IGF0IGFsbCwgYnV0IGluc3RlYWQsIDxsaXRlcmFsPlQ8L2xpdGVyYWw+IGlzIHVzZWQgYXMgdGhlIHJldHVybiB0eXBlLiAKT2J2aW91c2x5IDxsaXRlcmFsPlQ8L2xpdGVyYWw+IGNhbm5vdCBiZSBhbiBhcmJpdHJhcnkgdHlwZSwgdGhlIHRydWUgcmVzdWx0IG9mIHRoZSBsYW1iZGEgZnVuY3RvciBtdXN0IGJlIGltcGxpY2l0bHkgY29udmVydGlibGUgdG8gPGxpdGVyYWw+VDwvbGl0ZXJhbD4uIApGb3IgZXhhbXBsZToKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbQSBhOyBCIGI7CkMgb3BlcmF0b3IrKEEsIEIpOwppbnQgb3BlcmF0b3IqKEEsIEIpOyAKICAuLi4KcmV0PEQ+KF8xICsgXzIpKGEsIGIpOyAgICAgLy8gZXJyb3IgKEMgY2Fubm90IGJlIGNvbnZlcnRlZCB0byBEKQpyZXQ8Qz4oXzEgKyBfMikoYSwgYik7ICAgICAvLyBvawpyZXQ8ZmxvYXQ+KF8xICogXzIpKGEsIGIpOyAvLyBvayAoaW50IGNhbiBiZSBjb252ZXJ0ZWQgdG8gZmxvYXQpCiAgLi4uCnN0cnVjdCBYIHsKICBZIG9wZXJhdG9yKGludCkoKTsgICAKfTsKICAuLi4KWCB4OyBpbnQgaTsKYmluZCh4LCBfMSkoaSk7ICAgICAgICAgICAgLy8gZXJyb3IsIHJldHVybiB0eXBlIGNhbm5vdCBiZSBkZWR1Y2VkCnJldDxZPihiaW5kKHgsIF8xKSkoaSk7ICAgIC8vIG9rXV0+CjwvcHJvZ3JhbWxpc3Rpbmc+CkZvciBiaW5kIGV4cHJlc3Npb25zLCB0aGVyZSBpcyBhIHNob3J0LWhhbmQgbm90YXRpb24gdGhhdCBjYW4gYmUgdXNlZCBpbnN0ZWFkIG9mIDxsaXRlcmFsPnJldDwvbGl0ZXJhbD4uIApUaGUgbGFzdCBsaW5lIGNvdWxkIGFsdGVybmF0aXZlbHkgYmUgd3JpdHRlbiBhczoKCjxwcm9ncmFtbGlzdGluZz48IVtDREFUQVtiaW5kPFo+KHgsIF8xKShpKTtdXT48L3Byb2dyYW1saXN0aW5nPgpUaGlzIGZlYXR1cmUgaXMgbW9kZWxlZCBhZnRlciB0aGUgQm9vc3QgQmluZCBsaWJyYXJ5IDx4cmVmIGxpbmtlbmQ9ImNpdDpib29zdDo6YmluZCIvPi4KCjwvcGFyYT4KCjxwYXJhPk5vdGUgdGhhdCB3aXRoaW4gbmVzdGVkIGxhbWJkYSBleHByZXNzaW9ucywgCnRoZSA8bGl0ZXJhbD5yZXQ8L2xpdGVyYWw+IG11c3QgYmUgdXNlZCBhdCBlYWNoIHN1YmV4cHJlc3Npb24gd2hlcmUgCnRoZSBkZWR1Y3Rpb24gd291bGQgb3RoZXJ3aXNlIGZhaWwuIApGb3IgZXhhbXBsZToKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVtBIGE7IEIgYjsKQyBvcGVyYXRvcisoQSwgQik7IEQgb3BlcmF0b3ItKEMpOwogIC4uLgpyZXQ8RD4oIC0gKF8xICsgXzIpKShhLCBiKTsgLy8gZXJyb3IgCnJldDxEPiggLSByZXQ8Qz4oXzEgKyBfMikpKGEsIGIpOyAvLyBva11dPgo8L3Byb2dyYW1saXN0aW5nPgo8L3BhcmE+Cgo8cGFyYT5JZiB5b3UgZmluZCB5b3Vyc2VsZiB1c2luZyAgPGxpdGVyYWw+cmV0PC9saXRlcmFsPiByZXBlYXRlZGx5IHdpdGggdGhlIHNhbWUgdHlwZXMsIGl0IGlzIHdvcnRoIHdoaWxlIGV4dGVuZGluZyB0aGUgcmV0dXJuIHR5cGUgZGVkdWN0aW9uIChzZWUgPHhyZWYgbGlua2VuZD0ibGFtYmRhLmV4dGVuZGluZyIvPikuCjwvcGFyYT4KCjxzZWN0aW9uIGlkPSJsYW1iZGEubnVsbGFyeV9mdW5jdG9yc19hbmRfcmV0Ij4KPHRpdGxlPk51bGxhcnkgbGFtYmRhIGZ1bmN0b3JzIGFuZCByZXQ8L3RpdGxlPgoKPHBhcmE+CkFzIHN0YXRlZCBhYm92ZSwgdGhlIGVmZmVjdCBvZiA8bGl0ZXJhbD5yZXQ8L2xpdGVyYWw+IGlzIHRvIHByZXZlbnQgdGhlIHJldHVybiB0eXBlIGRlZHVjdGlvbiB0byBiZSBwZXJmb3JtZWQuIApIb3dldmVyLCB0aGVyZSBpcyBhbiBleGNlcHRpb24uIApEdWUgdG8gdGhlIHdheSB0aGUgQysrIHRlbXBsYXRlIGluc3RhbnRpYXRpb24gd29ya3MsIHRoZSBjb21waWxlciBpcyBhbHdheXMgZm9yY2VkIHRvIGluc3RhbnRpYXRlIHRoZSByZXR1cm4gdHlwZSBkZWR1Y3Rpb24gdGVtcGxhdGVzIGZvciB6ZXJvLWFyZ3VtZW50IGxhbWJkYSBmdW5jdG9ycy4KVGhpcyBpbnRyb2R1Y2VzIGEgc2xpZ2h0IHByb2JsZW0gd2l0aCA8bGl0ZXJhbD5yZXQ8L2xpdGVyYWw+LCBiZXN0IGRlc2NyaWJlZCB3aXRoIGFuIGV4YW1wbGU6Cgo8cHJvZ3JhbWxpc3Rpbmc+CjwhW0NEQVRBW3N0cnVjdCBGIHsgaW50IG9wZXJhdG9yKCkoaW50IGkpIGNvbnN0OyB9OyAKRiBmOwogIC4uLgpiaW5kKGYsIF8xKTsgICAgICAgICAgIC8vIGZhaWxzLCBjYW5ub3QgZGVkdWNlIHRoZSByZXR1cm4gdHlwZQpyZXQ8aW50PihiaW5kKGYsIF8xKSk7IC8vIG9rCiAgLi4uCmJpbmQoZiwgMSk7ICAgICAgICAgICAgLy8gZmFpbHMsIGNhbm5vdCBkZWR1Y2UgdGhlIHJldHVybiB0eXBlCnJldDxpbnQ+KGJpbmQoZiwgMSkpOyAgLy8gZmFpbHMgYXMgd2VsbCFdXT4KPC9wcm9ncmFtbGlzdGluZz4KVGhlIEJMTCBjYW5ub3QgZGVkdWNlIHRoZSByZXR1cm4gdHlwZXMgb2YgdGhlIGFib3ZlIGJpbmQgY2FsbHMsIGFzIDxsaXRlcmFsPkY8L2xpdGVyYWw+IGRvZXMgbm90IGRlZmluZSB0aGUgdHlwZWRlZiA8bGl0ZXJhbD5yZXN1bHRfdHlwZTwvbGl0ZXJhbD4uIApPbmUgd291bGQgZXhwZWN0IDxsaXRlcmFsPnJldDwvbGl0ZXJhbD4gdG8gZml4IHRoaXMsIGJ1dCBmb3IgdGhlIG51bGxhcnkgbGFtYmRhIGZ1bmN0b3IgdGhhdCByZXN1bHRzIGZyb20gYSBiaW5kIGV4cHJlc3Npb24gKGxhc3QgbGluZSBhYm92ZSkgdGhpcyBkb2VzIG5vdCB3b3JrLgpUaGUgcmV0dXJuIHR5cGUgZGVkdWN0aW9uIHRlbXBsYXRlcyBhcmUgaW5zdGFudGlhdGVkLCBldmVuIHRob3VnaCBpdCB3b3VsZCBub3QgYmUgbmVjZXNzYXJ5IGFuZCB0aGUgcmVzdWx0IGlzIGEgY29tcGlsYXRpb24gZXJyb3IuCjwvcGFyYT4KCjxwYXJhPlRoZSBzb2x1dGlvbiB0byB0aGlzIGlzIG5vdCB0byB1c2UgdGhlIDxsaXRlcmFsPnJldDwvbGl0ZXJhbD4gZnVuY3Rpb24sIGJ1dCByYXRoZXIgZGVmaW5lIHRoZSByZXR1cm4gdHlwZSBhcyBhbiBleHBsaWNpdGx5IHNwZWNpZmllZCB0ZW1wbGF0ZSBwYXJhbWV0ZXIgaW4gdGhlIDxsaXRlcmFsPmJpbmQ8L2xpdGVyYWw+IGNhbGw6Cjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbYmluZDxpbnQ+KGYsIDEpOyAgICAgICAvLyBva11dPgo8L3Byb2dyYW1saXN0aW5nPgoKVGhlIGxhbWJkYSBmdW5jdG9ycyBjcmVhdGVkIHdpdGggCjxsaXRlcmFsPnJldCZsdDs8cGFyYW1ldGVyPlQ8L3BhcmFtZXRlcj4mZ3Q7KGJpbmQoPHBhcmFtZXRlcj5hcmctbGlzdDwvcGFyYW1ldGVyPikpPC9saXRlcmFsPiBhbmQgCjxsaXRlcmFsPmJpbmQmbHQ7PHBhcmFtZXRlcj5UPC9wYXJhbWV0ZXI+Jmd0Oyg8cGFyYW1ldGVyPmFyZy1saXN0PC9wYXJhbWV0ZXI+KTwvbGl0ZXJhbD4gaGF2ZSB0aGUgZXhhY3Qgc2FtZSBmdW5jdGlvbmFsaXR5ICZtZGFzaDsKYXBhcnQgZnJvbSB0aGUgZmFjdCB0aGF0IGZvciBzb21lIG51bGxhcnkgbGFtYmRhIGZ1bmN0b3JzIHRoZSBmb3JtZXIgZG9lcyBub3Qgd29yayB3aGlsZSB0aGUgbGF0dGVyIGRvZXMuIAo8L3BhcmE+Cjwvc2VjdGlvbj4KPC9zZWN0aW9uPgoKCjxzZWN0aW9uIGlkPSJsYW1iZGEuZGVsYXlpbmdfY29uc3RhbnRzX2FuZF92YXJpYWJsZXMiPgo8dGl0bGU+RGVsYXlpbmcgY29uc3RhbnRzIGFuZCB2YXJpYWJsZXM8L3RpdGxlPgoKPHBhcmE+ClRoZSB1bmFyeSBmdW5jdGlvbnMgPGxpdGVyYWw+Y29uc3RhbnQ8L2xpdGVyYWw+LAo8bGl0ZXJhbD5jb25zdGFudF9yZWY8L2xpdGVyYWw+IGFuZCA8bGl0ZXJhbD52YXI8L2xpdGVyYWw+IHR1cm4gdGhlaXIgYXJndW1lbnQgaW50byBhIGxhbWJkYSBmdW5jdG9yLCB0aGF0IGltcGxlbWVudHMgYW4gaWRlbnRpdHkgbWFwcGluZy4KVGhlIGZvcm1lciB0d28gYXJlIGZvciBjb25zdGFudHMsIHRoZSBsYXR0ZXIgZm9yIHZhcmlhYmxlcy4gClRoZSB1c2Ugb2YgdGhlc2UgPGVtcGhhc2lzPmRlbGF5ZWQ8L2VtcGhhc2lzPiBjb25zdGFudHMgYW5kIHZhcmlhYmxlcyBpcyBzb21ldGltZXMgbmVjZXNzYXJ5IGR1ZSB0byB0aGUgbGFjayBvZiBleHBsaWNpdCBzeW50YXggZm9yIGxhbWJkYSBleHByZXNzaW9ucy4gCkZvciBleGFtcGxlOgo8cHJvZ3JhbWxpc3Rpbmc+CjwhW0NEQVRBW2Zvcl9lYWNoKGEuYmVnaW4oKSwgYS5lbmQoKSwgY291dCA8PCBfMSA8PCAnICcpOwpmb3JfZWFjaChhLmJlZ2luKCksIGEuZW5kKCksIGNvdXQgPDwgJyAnIDw8IF8xKTtdXT4KPC9wcm9ncmFtbGlzdGluZz4KVGhlIGZpcnN0IGxpbmUgb3V0cHV0cyB0aGUgZWxlbWVudHMgb2YgPGxpdGVyYWw+YTwvbGl0ZXJhbD4gc2VwYXJhdGVkIGJ5IHNwYWNlcywgd2hpbGUgdGhlIHNlY29uZCBsaW5lIG91dHB1dHMgYSBzcGFjZSBmb2xsb3dlZCBieSB0aGUgZWxlbWVudHMgb2YgPGxpdGVyYWw+YTwvbGl0ZXJhbD4gd2l0aG91dCBhbnkgc2VwYXJhdG9ycy4KVGhlIHJlYXNvbiBmb3IgdGhpcyBpcyB0aGF0IG5laXRoZXIgb2YgdGhlIG9wZXJhbmRzIG9mIAo8bGl0ZXJhbD48IVtDREFUQVtjb3V0IDw8ICcgJ11dPjwvbGl0ZXJhbD4gaXMgYSBsYW1iZGEgZXhwcmVzc2lvbiwgaGVuY2UgPGxpdGVyYWw+PCFbQ0RBVEFbY291dCA8PCAnICddXT48L2xpdGVyYWw+IGlzIGV2YWx1YXRlZCBpbW1lZGlhdGVseS4KClRvIGRlbGF5IHRoZSBldmFsdWF0aW9uIG9mIDxsaXRlcmFsPjwhW0NEQVRBW2NvdXQgPDwgJyAnXV0+PC9saXRlcmFsPiwgb25lIG9mIHRoZSBvcGVyYW5kcyBtdXN0IGJlIGV4cGxpY2l0bHkgbWFya2VkIGFzIGEgbGFtYmRhIGV4cHJlc3Npb24uIApUaGlzIGlzIGFjY29tcGxpc2hlZCB3aXRoIHRoZSA8bGl0ZXJhbD5jb25zdGFudDwvbGl0ZXJhbD4gZnVuY3Rpb246Cjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbZm9yX2VhY2goYS5iZWdpbigpLCBhLmVuZCgpLCBjb3V0IDw8IGNvbnN0YW50KCcgJykgPDwgXzEpO11dPgo8L3Byb2dyYW1saXN0aW5nPgoKVGhlIGNhbGwgPGxpdGVyYWw+Y29uc3RhbnQoJyAnKTwvbGl0ZXJhbD4gY3JlYXRlcyBhIG51bGxhcnkgbGFtYmRhIGZ1bmN0b3Igd2hpY2ggc3RvcmVzIHRoZSBjaGFyYWN0ZXIgY29uc3RhbnQgPGxpdGVyYWw+JyAnPC9saXRlcmFsPiAKYW5kIHJldHVybnMgYSByZWZlcmVuY2UgdG8gaXQgd2hlbiBpbnZva2VkLiAKVGhlIGZ1bmN0aW9uIDxsaXRlcmFsPmNvbnN0YW50X3JlZjwvbGl0ZXJhbD4gaXMgc2ltaWxhciwgZXhjZXB0IHRoYXQgaXQKc3RvcmVzIGEgY29uc3RhbnQgcmVmZXJlbmNlIHRvIGl0cyBhcmd1bWVudC4KClRoZSA8bGl0ZXJhbD5jb25zdGFudDwvbGl0ZXJhbD4gYW5kIDxsaXRlcmFsPmNvbnNhbnRfcmVmPC9saXRlcmFsPiBhcmUgb25seQpuZWVkZWQgd2hlbiB0aGUgb3BlcmF0b3IgY2FsbCBoYXMgc2lkZSBlZmZlY3RzLCBsaWtlIGluIHRoZSBhYm92ZSBleGFtcGxlLgo8L3BhcmE+Cgo8cGFyYT4KU29tZXRpbWVzIHdlIG5lZWQgdG8gZGVsYXkgdGhlIGV2YWx1YXRpb24gb2YgYSB2YXJpYWJsZS4gClN1cHBvc2Ugd2Ugd2FudGVkIHRvIG91dHB1dCB0aGUgZWxlbWVudHMgb2YgYSBjb250YWluZXIgaW4gYSBudW1iZXJlZCBsaXN0OgoKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVtpbnQgaW5kZXggPSAwOyAKZm9yX2VhY2goYS5iZWdpbigpLCBhLmVuZCgpLCBjb3V0IDw8ICsraW5kZXggPDwgJzonIDw8IF8xIDw8ICdcbicpOwpmb3JfZWFjaChhLmJlZ2luKCksIGEuZW5kKCksIGNvdXQgPDwgKyt2YXIoaW5kZXgpIDw8ICc6JyA8PCBfMSA8PCAnXG4nKTtdXT4KPC9wcm9ncmFtbGlzdGluZz4KClRoZSBmaXJzdCA8bGl0ZXJhbD5mb3JfZWFjaDwvbGl0ZXJhbD4gaW52b2NhdGlvbiBkb2VzIG5vdCBkbyB3aGF0IHdlIHdhbnQ7IDxsaXRlcmFsPmluZGV4PC9saXRlcmFsPiBpcyBpbmNyZW1lbnRlZCBvbmx5IG9uY2UsIGFuZCBpdHMgdmFsdWUgaXMgd3JpdHRlbiBpbnRvIHRoZSBvdXRwdXQgc3RyZWFtIG9ubHkgb25jZS4KQnkgdXNpbmcgPGxpdGVyYWw+dmFyPC9saXRlcmFsPiB0byBtYWtlIDxsaXRlcmFsPmluZGV4PC9saXRlcmFsPiBhIGxhbWJkYSBleHByZXNzaW9uLCB3ZSBnZXQgdGhlIGRlc2lyZWQgZWZmZWN0Lgo8IS0tIE5vdGUgdGhhdCA8bGl0ZXJhbD52YXI8L2xpdGVyYWw+IGFjY2VwdHMgY29uc3Qgb2JqZWN0cyBhcyB3ZWxsLCBpbiB3aGljaCBjYXNlCmNhbGxpbmcgPGxpdGVyYWw+dmFyPC9saXRlcmFsPiBlcXVhbHMgY2FsbGluZyA8bGl0ZXJhbD5jb25zdGFudF9yZWY8L2xpdGVyYWw+Li0tPgo8L3BhcmE+Cgo8cGFyYT4KSW4gc3VtLCA8bGl0ZXJhbD52YXIoeCk8L2xpdGVyYWw+IGNyZWF0ZXMgYSBudWxsYXJ5IGxhbWJkYSBmdW5jdG9yLCAKd2hpY2ggc3RvcmVzIGEgcmVmZXJlbmNlIHRvIHRoZSB2YXJpYWJsZSA8bGl0ZXJhbD54PC9saXRlcmFsPi4gCldoZW4gdGhlIGxhbWJkYSBmdW5jdG9yIGlzIGludm9rZWQsIGEgcmVmZXJlbmNlIHRvIDxsaXRlcmFsPng8L2xpdGVyYWw+IGlzIHJldHVybmVkLgo8L3BhcmE+Cgo8c2ltcGxlc2VjdD4KPHRpdGxlPk5hbWluZyBkZWxheWVkIGNvbnN0YW50cyBhbmQgdmFyaWFibGVzPC90aXRsZT4KCjxwYXJhPgpJdCBpcyBwb3NzaWJsZSB0byBwcmVkZWZpbmUgYW5kIG5hbWUgYSBkZWxheWVkIHZhcmlhYmxlIG9yIGNvbnN0YW50IG91dHNpZGUgYSBsYW1iZGEgZXhwcmVzc2lvbi4gClRoZSB0ZW1wbGF0ZXMgPGxpdGVyYWw+dmFyX3R5cGU8L2xpdGVyYWw+LCA8bGl0ZXJhbD5jb25zdGFudF90eXBlPC9saXRlcmFsPiAKYW5kIDxsaXRlcmFsPmNvbnN0YW50X3JlZl90eXBlPC9saXRlcmFsPiBzZXJ2ZSBmb3IgdGhpcyBwdXJwb3NlLiAKVGhleSBhcmUgdXNlZCBhczoKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVt2YXJfdHlwZTxUPjo6dHlwZSBkZWxheWVkX2kodmFyKGkpKTsKY29uc3RhbnRfdHlwZTxUPjo6dHlwZSBkZWxheWVkX2MoY29uc3RhbnQoYykpO11dPgo8L3Byb2dyYW1saXN0aW5nPgpUaGUgZmlyc3QgbGluZSBkZWZpbmVzIHRoZSB2YXJpYWJsZSA8bGl0ZXJhbD5kZWxheWVkX2k8L2xpdGVyYWw+IHdoaWNoIGlzIGEgZGVsYXllZCB2ZXJzaW9uIG9mIHRoZSB2YXJpYWJsZSA8bGl0ZXJhbD5pPC9saXRlcmFsPiBvZiB0eXBlIDxsaXRlcmFsPlQ8L2xpdGVyYWw+LgpBbmFsb2dvdXNseSwgdGhlIHNlY29uZCBsaW5lIGRlZmluZXMgdGhlIGNvbnN0YW50IDxsaXRlcmFsPmRlbGF5ZWRfYzwvbGl0ZXJhbD4gYXMgYSBkZWxheWVkIHZlcnNpb24gb2YgdGhlIGNvbnN0YW50IDxsaXRlcmFsPmM8L2xpdGVyYWw+LgpGb3IgZXhhbXBsZToKCjxwcm9ncmFtbGlzdGluZz4KaW50IGkgPSAwOyBpbnQgajsKZm9yX2VhY2goYS5iZWdpbigpLCBhLmVuZCgpLCAodmFyKGopID0gXzEsIF8xID0gdmFyKGkpLCB2YXIoaSkgPSB2YXIoaikpKTsgCjwvcHJvZ3JhbWxpc3Rpbmc+CmlzIGVxdWl2YWxlbnQgdG86Cjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbaW50IGkgPSAwOyBpbnQgajsKdmFyX3R5cGU8aW50Pjo6dHlwZSB2aSh2YXIoaSkpLCB2aih2YXIoaikpOwpmb3JfZWFjaChhLmJlZ2luKCksIGEuZW5kKCksICh2aiA9IF8xLCBfMSA9IHZpLCB2aSA9IHZqKSk7XV0+CjwvcHJvZ3JhbWxpc3Rpbmc+CjwvcGFyYT4KPHBhcmE+CkhlcmUgaXMgYW4gZXhhbXBsZSBvZiBuYW1pbmcgYSBkZWxheWVkIGNvbnN0YW50Ogo8cHJvZ3JhbWxpc3Rpbmc+CjwhW0NEQVRBW2NvbnN0YW50X3R5cGU8Y2hhcj46OnR5cGUgc3BhY2UoY29uc3RhbnQoJyAnKSk7CmZvcl9lYWNoKGEuYmVnaW4oKSxhLmVuZCgpLCBjb3V0IDw8IHNwYWNlIDw8IF8xKTtdXT4KPC9wcm9ncmFtbGlzdGluZz4KPC9wYXJhPgoKPC9zaW1wbGVzZWN0PgoKPHNpbXBsZXNlY3Q+Cjx0aXRsZT5BYm91dCBhc3NpZ25tZW50IGFuZCBzdWJzY3JpcHQgb3BlcmF0b3JzPC90aXRsZT4KCjxwYXJhPgpBcyBkZXNjcmliZWQgaW4gPHhyZWYgbGlua2VuZD0ibGFtYmRhLmFzc2lnbm1lbnRfYW5kX3N1YnNjcmlwdCIvPiwgYXNzaWdubWVudCBhbmQgc3Vic2NyaXB0aW5nIG9wZXJhdG9ycyBhcmUgYWx3YXlzIGRlZmluZWQgYXMgbWVtYmVyIGZ1bmN0aW9ucy4KVGhpcyBtZWFucywgdGhhdCBmb3IgZXhwcmVzc2lvbnMgb2YgdGhlIGZvcm0KPGxpdGVyYWw+eCA9IHk8L2xpdGVyYWw+IG9yIDxsaXRlcmFsPnhbeV08L2xpdGVyYWw+IHRvIGJlIGludGVycHJldGVkIGFzIGxhbWJkYSBleHByZXNzaW9ucywgdGhlIGxlZnQtaGFuZCBvcGVyYW5kIDxsaXRlcmFsPng8L2xpdGVyYWw+IG11c3QgYmUgYSBsYW1iZGEgZXhwcmVzc2lvbi4gCkNvbnNlcXVlbnRseSwgaXQgaXMgc29tZXRpbWVzIG5lY2Vzc2FyeSB0byB1c2UgPGxpdGVyYWw+dmFyPC9saXRlcmFsPiBmb3IgdGhpcyBwdXJwb3NlLgpXZSByZXBlYXQgdGhlIGV4YW1wbGUgZnJvbSA8eHJlZiBsaW5rZW5kPSJsYW1iZGEuYXNzaWdubWVudF9hbmRfc3Vic2NyaXB0Ii8+OgoKPHByb2dyYW1saXN0aW5nPgppbnQgaTsgCmkgPSBfMTsgICAgICAgLy8gZXJyb3IKdmFyKGkpID0gXzE7ICAvLyBvawo8L3Byb2dyYW1saXN0aW5nPgo8L3BhcmE+Cgo8cGFyYT4KCk5vdGUgdGhhdCB0aGUgY29tcG91bmQgYXNzaWdubWVudCBvcGVyYXRvcnMgPGxpdGVyYWw+Kz08L2xpdGVyYWw+LCA8bGl0ZXJhbD4tPTwvbGl0ZXJhbD4gZXRjLiBjYW4gYmUgZGVmaW5lZCBhcyBub24tbWVtYmVyIGZ1bmN0aW9ucywgYW5kIHRodXMgdGhleSBhcmUgaW50ZXJwcmV0ZWQgYXMgbGFtYmRhIGV4cHJlc3Npb25zIGV2ZW4gaWYgb25seSB0aGUgcmlnaHQtaGFuZCBvcGVyYW5kIGlzIGEgbGFtYmRhIGV4cHJlc3Npb24uCk5ldmVydGhlbGVzcywgaXQgaXMgcGVyZmVjdGx5IG9rIHRvIGRlbGF5IHRoZSBsZWZ0IG9wZXJhbmQgZXhwbGljaXRseS4gCkZvciBleGFtcGxlLCA8bGl0ZXJhbD5pICs9IF8xPC9saXRlcmFsPiBpcyBlcXVpdmFsZW50IHRvIDxsaXRlcmFsPnZhcihpKSArPSBfMTwvbGl0ZXJhbD4uCjwvcGFyYT4KPC9zaW1wbGVzZWN0PgoKPC9zZWN0aW9uPgoKPHNlY3Rpb24gaWQ9ImxhbWJkYS5sYW1iZGFfZXhwcmVzc2lvbnNfZm9yX2NvbnRyb2xfc3RydWN0dXJlcyI+Cjx0aXRsZT5MYW1iZGEgZXhwcmVzc2lvbnMgZm9yIGNvbnRyb2wgc3RydWN0dXJlczwvdGl0bGU+Cgo8cGFyYT4KQkxMIGRlZmluZXMgc2V2ZXJhbCBmdW5jdGlvbnMgdG8gY3JlYXRlIGxhbWJkYSBmdW5jdG9ycyB0aGF0IHJlcHJlc2VudCBjb250cm9sIHN0cnVjdHVyZXMuIApUaGV5IGFsbCB0YWtlIGxhbWJkYSBmdW5jdG9ycyBhcyBwYXJhbWV0ZXJzIGFuZCByZXR1cm4gPGxpdGVyYWw+dm9pZDwvbGl0ZXJhbD4uClRvIHN0YXJ0IHdpdGggYW4gZXhhbXBsZSwgdGhlIGZvbGxvd2luZyBjb2RlIG91dHB1dHMgYWxsIGV2ZW4gZWxlbWVudHMgb2Ygc29tZSBjb250YWluZXIgPGxpdGVyYWw+YTwvbGl0ZXJhbD46Cgo8cHJvZ3JhbWxpc3Rpbmc+CjwhW0NEQVRBW2Zvcl9lYWNoKGEuYmVnaW4oKSwgYS5lbmQoKSwgCiAgICAgICAgIGlmX3RoZW4oXzEgJSAyID09IDAsIGNvdXQgPDwgXzEpKTtdXT4gIAo8L3Byb2dyYW1saXN0aW5nPgo8L3BhcmE+Cgo8cGFyYT4KVGhlIEJMTCBzdXBwb3J0cyB0aGUgZm9sbG93aW5nIGZ1bmN0aW9uIHRlbXBsYXRlcyBmb3IgY29udHJvbCBzdHJ1Y3R1cmVzOiAKCjxwcm9ncmFtbGlzdGluZz4KaWZfdGhlbihjb25kaXRpb24sIHRoZW5fcGFydCkKaWZfdGhlbl9lbHNlKGNvbmRpdGlvbiwgdGhlbl9wYXJ0LCBlbHNlX3BhcnQpCmlmX3RoZW5fZWxzZV9yZXR1cm4oY29uZGl0aW9uLCB0aGVuX3BhcnQsIGVsc2VfcGFydCkKd2hpbGVfbG9vcChjb25kaXRpb24sIGJvZHkpCndoaWxlX2xvb3AoY29uZGl0aW9uKSAvLyBubyBib2R5IGNhc2UKZG9fd2hpbGVfbG9vcChjb25kaXRpb24sIGJvZHkpCmRvX3doaWxlX2xvb3AoY29uZGl0aW9uKSAvLyBubyBib2R5IGNhc2UgCmZvcl9sb29wKGluaXQsIGNvbmRpdGlvbiwgaW5jcmVtZW50LCBib2R5KQpmb3JfbG9vcChpbml0LCBjb25kaXRpb24sIGluY3JlbWVudCkgLy8gbm8gYm9keSBjYXNlCnN3aXRjaF9zdGF0ZW1lbnQoLi4uKQo8L3Byb2dyYW1saXN0aW5nPgoKVGhlIHJldHVybiB0eXBlcyBvZiBhbGwgY29udHJvbCBjb25zdHJ1Y3QgbGFtYmRhIGZ1bmN0b3IgaXMgCjxsaXRlcmFsPnZvaWQ8L2xpdGVyYWw+LCBleGNlcHQgZm9yIDxsaXRlcmFsPmlmX3RoZW5fZWxzZV9yZXR1cm48L2xpdGVyYWw+LAp3aGljaCB3cmFwcyBhIGNhbGwgdG8gdGhlIGNvbmRpdGlvbmFsIG9wZXJhdG9yIAo8cHJvZ3JhbWxpc3Rpbmc+CmNvbmRpdGlvbiA/IHRoZW5fcGFydCA6IGVsc2VfcGFydAo8L3Byb2dyYW1saXN0aW5nPgpUaGUgcmV0dXJuIHR5cGUgcnVsZXMgZm9yIHRoaXMgb3BlcmF0b3IgYXJlIHNvbWV3aGF0IGNvbXBsZXguIApCYXNpY2FsbHksIGlmIHRoZSBicmFuY2hlcyBoYXZlIHRoZSBzYW1lIHR5cGUsIHRoaXMgdHlwZSBpcyB0aGUgcmV0dXJuIHR5cGUuCklmIHRoZSB0eXBlIG9mIHRoZSBicmFuY2hlcyBkaWZmZXIsIG9uZSBicmFuY2gsIHNheSBvZiB0eXBlIAo8bGl0ZXJhbD5BPC9saXRlcmFsPiwgbXVzdCBiZSBjb252ZXJ0aWJsZSB0byB0aGUgb3RoZXIgYnJhbmNoLCAKc2F5IG9mIHR5cGUgPGxpdGVyYWw+QjwvbGl0ZXJhbD4uCkluIHRoaXMgc2l0dWF0aW9uLCB0aGUgcmVzdWx0IHR5cGUgaXMgPGxpdGVyYWw+QjwvbGl0ZXJhbD4uCkZ1cnRoZXIsIGlmIHRoZSBjb21tb24gdHlwZSBpcyBhbiBsdmFsdWUsIHRoZSByZXR1cm4gdHlwZSB3aWxsIGJlIGFuIGx2YWx1ZQp0b28uCjwvcGFyYT4KCgo8cGFyYT4KRGVsYXllZCB2YXJpYWJsZXMgdGVuZCB0byBiZSBjb21tb25wbGFjZSBpbiBjb250cm9sIHN0cnVjdHVyZSBsYW1iZGEgZXhwcmVzc2lvbnMuIApGb3IgaW5zdGFuY2UsIGhlcmUgd2UgdXNlIHRoZSA8bGl0ZXJhbD52YXI8L2xpdGVyYWw+IGZ1bmN0aW9uIHRvIHR1cm4gdGhlIGFyZ3VtZW50cyBvZiA8bGl0ZXJhbD5mb3JfbG9vcDwvbGl0ZXJhbD4gaW50byBsYW1iZGEgZXhwcmVzc2lvbnMuIApUaGUgZWZmZWN0IG9mIHRoZSBjb2RlIGlzIHRvIGFkZCAxIHRvIGVhY2ggZWxlbWVudCBvZiBhIHR3by1kaW1lbnNpb25hbCBhcnJheToKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbaW50IGFbNV1bMTBdOyBpbnQgaTsKZm9yX2VhY2goYSwgYSs1LCAKICBmb3JfbG9vcCh2YXIoaSk9MCwgdmFyKGkpPDEwLCArK3ZhcihpKSwgCiAgICAgICAgICAgXzFbdmFyKGkpXSArPSAxKSk7XV0+ICAKPC9wcm9ncmFtbGlzdGluZz4KCjwhLS0KQXMgZXhwbGFpbmVkIGluIDx4cmVmIGxpbmtlbmQ9ImxhbWJkYS5kZWxheWluZ19jb25zdGFudHNfYW5kX3ZhcmlhYmxlcyIvPiwgd2UgY2FuIGF2b2lkIHRoZSByZXBlYXRlZCB1c2Ugb2Ygd3JhcHBpbmcgb2YgPGxpdGVyYWw+dmFyPC9saXRlcmFsPiBpZiB3ZSBkZWZpbmUgaXQgYmVmb3JlaGFuZDoKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbaW50IGk7CnZhcl90eXBlPGludD46OnR5cGUgdmkodmFyKGkpKTsKZm9yX2VhY2goYSwgYSs1LCAKICBmb3JfbG9vcCh2aT0wLCB2aTwxMCwgKyt2aSwgXzFbdmldICs9IDYpKTtdXT4gIAo8L3Byb2dyYW1saXN0aW5nPgoKLS0+CjwvcGFyYT4KCjxwYXJhPgpUaGUgQkxMIHN1cHBvcnRzIGFuIGFsdGVybmF0aXZlIHN5bnRheCBmb3IgY29udHJvbCBleHByZXNzaW9ucywgc3VnZ2VzdGVkCmJ5IEpvZWwgZGUgR3V6bWFubi4gCkJ5IG92ZXJsb2FkaW5nIHRoZSA8bGl0ZXJhbD5vcGVyYXRvcltdPC9saXRlcmFsPiB3ZSBjYW4KZ2V0IGEgY2xvc2VyIHJlc2VtYmxhbmNlIHdpdGggdGhlIGJ1aWx0LWluIGNvbnRyb2wgc3RydWN0dXJlczoKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbaWZfKGNvbmRpdGlvbilbdGhlbl9wYXJ0XQppZl8oY29uZGl0aW9uKVt0aGVuX3BhcnRdLmVsc2VfW2Vsc2VfcGFydF0Kd2hpbGVfKGNvbmRpdGlvbilbYm9keV0KZG9fW2JvZHldLndoaWxlXyhjb25kaXRpb24pCmZvcl8oaW5pdCwgY29uZGl0aW9uLCBpbmNyZW1lbnQpW2JvZHldXV0+CjwvcHJvZ3JhbWxpc3Rpbmc+CgpGb3IgZXhhbXBsZSwgdXNpbmcgdGhpcyBzeW50YXggdGhlIDxsaXRlcmFsPmlmX3RoZW48L2xpdGVyYWw+IGV4YW1wbGUgYWJvdmUKY2FuIGJlIHdyaXR0ZW4gYXM6Cjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbZm9yX2VhY2goYS5iZWdpbigpLCBhLmVuZCgpLCAKICAgICAgICAgaWZfKF8xICUgMiA9PSAwKVsgY291dCA8PCBfMSBdKV1dPiAgCjwvcHJvZ3JhbWxpc3Rpbmc+CgpBcyBtb3JlIGV4cGVyaWVuY2UgaXMgZ2FpbmVkLCB3ZSBtYXkgZW5kIHVwIGRlcHJlY2F0aW5nIG9uZSBvciB0aGUgb3RoZXIgCm9mIHRoZXNlIHN5bnRhY2VzLiAKCjwvcGFyYT4KCgoKPHNlY3Rpb24gaWQ9ImxhbWJkYS5zd2l0Y2hfc3RhdGVtZW50Ij4KPHRpdGxlPlN3aXRjaCBzdGF0ZW1lbnQ8L3RpdGxlPgo8L3NlY3Rpb24+Cgo8cGFyYT4KVGhlIGxhbWJkYSBleHByZXNzaW9ucyBmb3IgPGxpdGVyYWw+c3dpdGNoPC9saXRlcmFsPiBjb250cm9sIHN0cnVjdHVyZXMgYXJlIG1vcmUgY29tcGxleCBzaW5jZSB0aGUgbnVtYmVyIG9mIGNhc2VzIG1heSB2YXJ5LiAKVGhlIGdlbmVyYWwgZm9ybSBvZiBhIHN3aXRjaCBsYW1iZGEgZXhwcmVzc2lvbiBpczoKCjxwcm9ncmFtbGlzdGluZz4Kc3dpdGNoX3N0YXRlbWVudCg8cGFyYW1ldGVyPmNvbmRpdGlvbjwvcGFyYW1ldGVyPiwgCiAgY2FzZV9zdGF0ZW1lbnQmbHQ7PHBhcmFtZXRlcj5sYWJlbDwvcGFyYW1ldGVyPiZndDsoPHBhcmFtZXRlcj5sYW1iZGEgZXhwcmVzc2lvbjwvcGFyYW1ldGVyPiksCiAgY2FzZV9zdGF0ZW1lbnQmbHQ7PHBhcmFtZXRlcj5sYWJlbDwvcGFyYW1ldGVyPiZndDsoPHBhcmFtZXRlcj5sYW1iZGEgZXhwcmVzc2lvbjwvcGFyYW1ldGVyPiksCiAgLi4uCiAgZGVmYXVsdF9zdGF0ZW1lbnQoPHBhcmFtZXRlcj5sYW1iZGEgZXhwcmVzc2lvbjwvcGFyYW1ldGVyPikKKQo8L3Byb2dyYW1saXN0aW5nPgoKVGhlIDxsaXRlcmFsPjxwYXJhbWV0ZXI+Y29uZGl0aW9uPC9wYXJhbWV0ZXI+PC9saXRlcmFsPiBhcmd1bWVudCBtdXN0IGJlIGEgbGFtYmRhIGV4cHJlc3Npb24gdGhhdCBjcmVhdGVzIGEgbGFtYmRhIGZ1bmN0b3Igd2l0aCBhbiBpbnRlZ3JhbCByZXR1cm4gdHlwZS4KVGhlIGRpZmZlcmVudCBjYXNlcyBhcmUgY3JlYXRlZCB3aXRoIHRoZSA8bGl0ZXJhbD5jYXNlX3N0YXRlbWVudDwvbGl0ZXJhbD4gZnVuY3Rpb25zLCBhbmQgdGhlIG9wdGlvbmFsIGRlZmF1bHQgY2FzZSB3aXRoIHRoZSA8bGl0ZXJhbD5kZWZhdWx0X3N0YXRlbWVudDwvbGl0ZXJhbD4gZnVuY3Rpb24uClRoZSBjYXNlIGxhYmVscyBhcmUgZ2l2ZW4gYXMgZXhwbGljaXRseSBzcGVjaWZpZWQgdGVtcGxhdGUgYXJndW1lbnRzIHRvIDxsaXRlcmFsPmNhc2Vfc3RhdGVtZW50PC9saXRlcmFsPiBmdW5jdGlvbnMgYW5kIAo8bGl0ZXJhbD5icmVhazwvbGl0ZXJhbD4gc3RhdGVtZW50cyBhcmUgaW1wbGljaXRseSBwYXJ0IG9mIGVhY2ggY2FzZS4gCkZvciBleGFtcGxlLCA8bGl0ZXJhbD48IVtDREFUQVtjYXNlX3N0YXRlbWVudDwxPihhKV1dPjwvbGl0ZXJhbD4sIHdoZXJlIDxsaXRlcmFsPmE8L2xpdGVyYWw+IGlzIHNvbWUgbGFtYmRhIGZ1bmN0b3IsICBnZW5lcmF0ZXMgdGhlIGNvZGU6Cgo8cHJvZ3JhbWxpc3Rpbmc+CmNhc2UgMTogCiAgPHBhcmFtZXRlcj5ldmFsdWF0ZSBsYW1iZGEgZnVuY3RvcjwvcGFyYW1ldGVyPiBhOyAKICBicmVhazsKPC9wcm9ncmFtbGlzdGluZz4KVGhlIDxsaXRlcmFsPnN3aXRjaF9zdGF0ZW1lbnQ8L2xpdGVyYWw+IGZ1bmN0aW9uIGlzIHNwZWNpYWxpemVkIGZvciB1cCB0byA5IGNhc2Ugc3RhdGVtZW50cy4KCjwvcGFyYT4KCjxwYXJhPgpBcyBhIGNvbmNyZXRlIGV4YW1wbGUsIHRoZSBmb2xsb3dpbmcgY29kZSBpdGVyYXRlcyBvdmVyIHNvbWUgY29udGFpbmVyIDxsaXRlcmFsPnY8L2xpdGVyYWw+IGFuZCBvdXB0dXRzIDxxdW90ZT56ZXJvPC9xdW90ZT4gZm9yIGVhY2ggPGxpdGVyYWw+MDwvbGl0ZXJhbD4sIDxxdW90ZT5vbmU8L3F1b3RlPiBmb3IgZWFjaCA8bGl0ZXJhbD4xPC9saXRlcmFsPiwgYW5kIDxxdW90ZT5vdGhlcjogPHBhcmFtZXRlcj5uPC9wYXJhbWV0ZXI+PC9xdW90ZT4gZm9yIGFueSBvdGhlciB2YWx1ZSA8cGFyYW1ldGVyPm48L3BhcmFtZXRlcj4uCk5vdGUgdGhhdCBhbm90aGVyIGxhbWJkYSBleHByZXNzaW9uIGlzIHNlcXVlbmNlZCBhZnRlciB0aGUgPGxpdGVyYWw+c3dpdGNoX3N0YXRlbWVudDwvbGl0ZXJhbD4gdG8gb3V0cHV0IGEgbGluZSBicmVhayBhZnRlciBlYWNoIGVsZW1lbnQ6Cgo8cHJvZ3JhbWxpc3Rpbmc+CjwhW0NEQVRBW3N0ZDo6Zm9yX2VhY2godi5iZWdpbigpLCB2LmVuZCgpLAogICggCiAgICBzd2l0Y2hfc3RhdGVtZW50KAogICAgICBfMSwKICAgICAgY2FzZV9zdGF0ZW1lbnQ8MD4oc3RkOjpjb3V0IDw8IGNvbnN0YW50KCJ6ZXJvIikpLAogICAgICBjYXNlX3N0YXRlbWVudDwxPihzdGQ6OmNvdXQgPDwgY29uc3RhbnQoIm9uZSIpKSwKICAgICAgZGVmYXVsdF9zdGF0ZW1lbnQoY291dCA8PCBjb25zdGFudCgib3RoZXI6ICIpIDw8IF8xKQogICAgKSwgCiAgICBjb3V0IDw8IGNvbnN0YW50KCJcbiIpIAogICkKKTtdXT4KPC9wcm9ncmFtbGlzdGluZz4KPC9wYXJhPgoKPC9zZWN0aW9uPgoKPHNlY3Rpb24gaWQ9ImxhbWJkYS5leGNlcHRpb25zIj4KPHRpdGxlPkV4Y2VwdGlvbnM8L3RpdGxlPgoKPHBhcmE+ClRoZSBCTEwgcHJvdmlkZXMgbGFtYmRhIGZ1bmN0b3JzIHRoYXQgdGhyb3cgYW5kIGNhdGNoIGV4Y2VwdGlvbnMuCkxhbWJkYSBmdW5jdG9ycyBmb3IgdGhyb3dpbmcgZXhjZXB0aW9ucyBhcmUgY3JlYXRlZCB3aXRoIHRoZSB1bmFyeSBmdW5jdGlvbiA8bGl0ZXJhbD50aHJvd19leGNlcHRpb248L2xpdGVyYWw+LgpUaGUgYXJndW1lbnQgdG8gdGhpcyBmdW5jdGlvbiBpcyB0aGUgZXhjZXB0aW9uIHRvIGJlIHRocm93biwgb3IgYSBsYW1iZGEgZnVuY3RvciB3aGljaCBjcmVhdGVzIHRoZSBleGNlcHRpb24gdG8gYmUgdGhyb3duLgpBIGxhbWJkYSBmdW5jdG9yIGZvciByZXRocm93aW5nIGV4Y2VwdGlvbnMgaXMgY3JlYXRlZCB3aXRoIHRoZSBudWxsYXJ5IDxsaXRlcmFsPnJldGhyb3c8L2xpdGVyYWw+IGZ1bmN0aW9uLgo8L3BhcmE+Cgo8cGFyYT4KTGFtYmRhIGV4cHJlc3Npb25zIGZvciBoYW5kbGluZyBleGNlcHRpb25zIGFyZSBzb21ld2hhdCBtb3JlIGNvbXBsZXguClRoZSBnZW5lcmFsIGZvcm0gb2YgYSBsYW1iZGEgZXhwcmVzc2lvbiBmb3IgdHJ5IGNhdGNoIGJsb2NrcyBpcyBhcyBmb2xsb3dzOgoKPHByb2dyYW1saXN0aW5nPgp0cnlfY2F0Y2goCiAgPHBhcmFtZXRlcj5sYW1iZGEgZXhwcmVzc2lvbjwvcGFyYW1ldGVyPiwKICBjYXRjaF9leGNlcHRpb24mbHQ7PHBhcmFtZXRlcj50eXBlPC9wYXJhbWV0ZXI+Jmd0Oyg8cGFyYW1ldGVyPmxhbWJkYSBleHByZXNzaW9uPC9wYXJhbWV0ZXI+KSwKICBjYXRjaF9leGNlcHRpb24mbHQ7PHBhcmFtZXRlcj50eXBlPC9wYXJhbWV0ZXI+Jmd0Oyg8cGFyYW1ldGVyPmxhbWJkYSBleHByZXNzaW9uPC9wYXJhbWV0ZXI+KSwKICAuLi4KICBjYXRjaF9hbGwoPHBhcmFtZXRlcj5sYW1iZGEgZXhwcmVzc2lvbjwvcGFyYW1ldGVyPikKKQo8L3Byb2dyYW1saXN0aW5nPgoKVGhlIGZpcnN0IGxhbWJkYSBleHByZXNzaW9uIGlzIHRoZSB0cnkgYmxvY2suIApFYWNoIDxsaXRlcmFsPmNhdGNoX2V4Y2VwdGlvbjwvbGl0ZXJhbD4gZGVmaW5lcyBhIGNhdGNoIGJsb2NrIHdoZXJlIHRoZSAKZXhwbGljaXRseSBzcGVjaWZpZWQgdGVtcGxhdGUgYXJndW1lbnQgZGVmaW5lcyB0aGUgdHlwZSBvZiB0aGUgZXhjZXB0aW9uIAp0byBjYXRjaC4KClRoZSBsYW1iZGEgZXhwcmVzc2lvbiB3aXRoaW4gdGhlIDxsaXRlcmFsPmNhdGNoX2V4Y2VwdGlvbjwvbGl0ZXJhbD4gZGVmaW5lcyAKdGhlIGFjdGlvbnMgdG8gdGFrZSBpZiB0aGUgZXhjZXB0aW9uIGlzIGNhdWdodC4KCk5vdGUgdGhhdCB0aGUgcmVzdWx0aW5nIGV4Y2VwdGlvbiBoYW5kbGVycyBjYXRjaCB0aGUgZXhjZXB0aW9ucyBhcyAKcmVmZXJlbmNlcywgaS5lLiwgPGxpdGVyYWw+Y2F0Y2hfZXhjZXB0aW9uJmx0O1QmZ3Q7KC4uLik8L2xpdGVyYWw+IApyZXN1bHRzIGluIHRoZSBjYXRjaCBibG9jazoKCjxwcm9ncmFtbGlzdGluZz4KY2F0Y2goVCZhbXA7IGUpIHsgLi4uIH0KPC9wcm9ncmFtbGlzdGluZz4KClRoZSBsYXN0IGNhdGNoIGJsb2NrIGNhbiBhbHRlcm5hdGl2ZWx5IGJlIGEgY2FsbCB0byAKPGxpdGVyYWw+Y2F0Y2hfZXhjZXB0aW9uJmx0OzxwYXJhbWV0ZXI+dHlwZTwvcGFyYW1ldGVyPiZndDs8L2xpdGVyYWw+IApvciB0byAKPGxpdGVyYWw+Y2F0Y2hfYWxsPC9saXRlcmFsPiwgd2hpY2ggaXMgdGhlIGxhbWJkYSBleHByZXNzaW9uIGVxdWl2YWxlbnQgdG8gCjxsaXRlcmFsPmNhdGNoKC4uLik8L2xpdGVyYWw+LgoKPC9wYXJhPgoKPHBhcmE+CgpUaGUgPHhyZWYgbGlua2VuZD0iZXg6ZXhjZXB0aW9ucyIvPiBkZW1vbnN0cmF0ZXMgdGhlIHVzZSBvZiB0aGUgQkxMIApleGNlcHRpb24gaGFuZGxpbmcgdG9vbHMuIApUaGUgZmlyc3QgaGFuZGxlciBjYXRjaGVzIGV4Y2VwdGlvbnMgb2YgdHlwZSA8bGl0ZXJhbD5mb29fZXhjZXB0aW9uPC9saXRlcmFsPi4gCk5vdGUgdGhlIHVzZSBvZiA8bGl0ZXJhbD5fMTwvbGl0ZXJhbD4gcGxhY2Vob2xkZXIgaW4gdGhlIGJvZHkgb2YgdGhlIGhhbmRsZXIuCjwvcGFyYT4KCjxwYXJhPgpUaGUgc2Vjb25kIGhhbmRsZXIgc2hvd3MgaG93IHRvIHRocm93IGV4Y2VwdGlvbnMsIGFuZCBkZW1vbnN0cmF0ZXMgdGhlIAp1c2Ugb2YgdGhlIDxlbXBoYXNpcz5leGNlcHRpb24gcGxhY2Vob2xkZXI8L2VtcGhhc2lzPiA8bGl0ZXJhbD5fZTwvbGl0ZXJhbD4uCgpJdCBpcyBhIHNwZWNpYWwgcGxhY2Vob2xkZXIsIHdoaWNoIHJlZmVycyB0byB0aGUgY2F1Z2h0IGV4Y2VwdGlvbiBvYmplY3QgCndpdGhpbiB0aGUgaGFuZGxlciBib2R5LgoKSGVyZSB3ZSBhcmUgaGFuZGxpbmcgYW4gZXhjZXB0aW9uIG9mIHR5cGUgPGxpdGVyYWw+c3RkOjpleGNlcHRpb248L2xpdGVyYWw+LCAKd2hpY2ggY2FycmllcyBhIHN0cmluZyBleHBsYWluaW5nIHRoZSBjYXVzZSBvZiB0aGUgZXhjZXB0aW9uLiAKClRoaXMgZXhwbGFuYXRpb24gY2FuIGJlIHF1ZXJpZWQgd2l0aCB0aGUgemVyby1hcmd1bWVudCBtZW1iZXIgCmZ1bmN0aW9uIDxsaXRlcmFsPndoYXQ8L2xpdGVyYWw+LgoKVGhlIGV4cHJlc3Npb24KPGxpdGVyYWw+YmluZCgmYW1wO3N0ZDo6ZXhjZXB0aW9uOjp3aGF0LCBfZSk8L2xpdGVyYWw+IGNyZWF0ZXMgdGhlIGxhbWJkYSAKZnVuY3Rpb24gZm9yIG1ha2luZyB0aGF0IGNhbGwuCgpOb3RlIHRoYXQgPGxpdGVyYWw+X2U8L2xpdGVyYWw+IGNhbm5vdCBiZSB1c2VkIG91dHNpZGUgb2YgYW4gZXhjZXB0aW9uIGhhbmRsZXIgbGFtYmRhIGV4cHJlc3Npb24uCjwhLS1WaW9sYXRpbmcgdGhpcyBydWxlIGlzIGNhdWdodCBieSB0aGUgY29tcGlsZXIuLS0+CgpUaGUgbGFzdCBsaW5lIG9mIHRoZSBzZWNvbmQgaGFuZGxlciBjb25zdHJ1Y3RzIGEgbmV3IGV4Y2VwdGlvbiBvYmplY3QgYW5kIAp0aHJvd3MgdGhhdCB3aXRoIDxsaXRlcmFsPnRocm93IGV4Y2VwdGlvbjwvbGl0ZXJhbD4uIAoKQ29uc3RydWN0aW5nIGFuZCBkZXN0cnVjdGluZyBvYmplY3RzIHdpdGhpbiBsYW1iZGEgZXhwcmVzc2lvbnMgaXMgCmV4cGxhaW5lZCBpbiA8eHJlZiBsaW5rZW5kPSJsYW1iZGEuY29uc3RydWN0aW9uX2FuZF9kZXN0cnVjdGlvbiIvPgo8L3BhcmE+Cgo8cGFyYT4KRmluYWxseSwgdGhlIHRoaXJkIGhhbmRsZXIgKDxsaXRlcmFsPmNhdGNoX2FsbDwvbGl0ZXJhbD4pIGRlbW9uc3RyYXRlcyAKcmV0aHJvd2luZyBleGNlcHRpb25zLgo8L3BhcmE+Cgo8ZXhhbXBsZSBpZD0iZXg6ZXhjZXB0aW9ucyI+Cjx0aXRsZT5UaHJvd2luZyBhbmQgaGFuZGxpbmcgZXhjZXB0aW9ucyBpbiBsYW1iZGEgZXhwcmVzc2lvbnMuPC90aXRsZT4KPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVtmb3JfZWFjaCgKICBhLmJlZ2luKCksIGEuZW5kKCksCiAgdHJ5X2NhdGNoKAogICAgYmluZChmb28sIF8xKSwgICAgICAgICAgICAgICAgIC8vIGZvbyBtYXkgdGhyb3cKICAgIGNhdGNoX2V4Y2VwdGlvbjxmb29fZXhjZXB0aW9uPigKICAgICAgY291dCA8PCBjb25zdGFudCgiQ2F1Z2h0IGZvb19leGNlcHRpb246ICIpIAogICAgICAgICAgIDw8ICJmb28gd2FzIGNhbGxlZCB3aXRoIGFyZ3VtZW50ID0gIiA8PCBfMQogICAgKSwKICAgIGNhdGNoX2V4Y2VwdGlvbjxzdGQ6OmV4Y2VwdGlvbj4oCiAgICAgIGNvdXQgPDwgY29uc3RhbnQoIkNhdWdodCBzdGQ6OmV4Y2VwdGlvbjogIikgCiAgICAgICAgICAgPDwgYmluZCgmc3RkOjpleGNlcHRpb246OndoYXQsIF9lKSwKICAgICAgdGhyb3dfZXhjZXB0aW9uKGJpbmQoY29uc3RydWN0b3I8YmFyX2V4Y2VwdGlvbj4oKSwgXzEpKSkKICAgICksICAgICAgCiAgICBjYXRjaF9hbGwoCiAgICAgIChjb3V0IDw8IGNvbnN0YW50KCJVbmtub3duIiksIHJldGhyb3coKSkKICAgICkKICApCik7XV0+CjwvcHJvZ3JhbWxpc3Rpbmc+CjwvZXhhbXBsZT4KCjwvc2VjdGlvbj4KCjxzZWN0aW9uIGlkPSJsYW1iZGEuY29uc3RydWN0aW9uX2FuZF9kZXN0cnVjdGlvbiI+Cjx0aXRsZT5Db25zdHJ1Y3Rpb24gYW5kIGRlc3RydWN0aW9uPC90aXRsZT4KCgo8cGFyYT4KT3BlcmF0b3JzIDxsaXRlcmFsPm5ldzwvbGl0ZXJhbD4gYW5kIDxsaXRlcmFsPmRlbGV0ZTwvbGl0ZXJhbD4gY2FuIGJlIApvdmVybG9hZGVkLCBidXQgdGhlaXIgcmV0dXJuIHR5cGVzIGFyZSBmaXhlZC4gCgpQYXJ0aWN1bGFybHksIHRoZSByZXR1cm4gdHlwZXMgY2Fubm90IGJlIGxhbWJkYSBmdW5jdG9ycywgCndoaWNoIHByZXZlbnRzIHRoZW0gdG8gYmUgb3ZlcmxvYWRlZCBmb3IgbGFtYmRhIGV4cHJlc3Npb25zLgoKSXQgaXMgbm90IHBvc3NpYmxlIHRvIHRha2UgdGhlIGFkZHJlc3Mgb2YgYSBjb25zdHJ1Y3RvciwgCmhlbmNlIGNvbnN0cnVjdG9ycyBjYW5ub3QgYmUgdXNlZCBhcyB0YXJnZXQgZnVuY3Rpb25zIGluIGJpbmQgZXhwcmVzc2lvbnMuCgpUaGUgc2FtZSBpcyB0cnVlIGZvciBkZXN0cnVjdG9ycy4KCkFzIGEgd2F5IGFyb3VuZCB0aGVzZSBjb25zdHJhaW50cywgQkxMIGRlZmluZXMgd3JhcHBlciBjbGFzc2VzIGZvciAKPGxpdGVyYWw+bmV3PC9saXRlcmFsPiBhbmQgPGxpdGVyYWw+ZGVsZXRlPC9saXRlcmFsPiBjYWxscywgCmFzIHdlbGwgYXMgZm9yIGNvbnN0cnVjdG9ycyBhbmQgZGVzdHJ1Y3RvcnMuCgpJbnN0YW5jZXMgb2YgdGhlc2UgY2xhc3NlcyBhcmUgZnVuY3Rpb24gb2JqZWN0cywgdGhhdCBjYW4gYmUgdXNlZCBhcyAKdGFyZ2V0IGZ1bmN0aW9ucyBvZiBiaW5kIGV4cHJlc3Npb25zLiAKCkZvciBleGFtcGxlOgoKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVtpbnQqIGFbMTBdOwpmb3JfZWFjaChhLCBhKzEwLCBfMSA9IGJpbmQobmV3X3B0cjxpbnQ+KCkpKTsgCmZvcl9lYWNoKGEsIGErMTAsIGJpbmQoZGVsZXRlX3B0cigpLCBfMSkpO11dPgo8L3Byb2dyYW1saXN0aW5nPgoKVGhlIDxsaXRlcmFsPm5ld19wdHImbHQ7aW50Jmd0OygpPC9saXRlcmFsPiBleHByZXNzaW9uIGNyZWF0ZXMgCmEgZnVuY3Rpb24gb2JqZWN0IHRoYXQgY2FsbHMgPGxpdGVyYWw+bmV3IGludCgpPC9saXRlcmFsPiB3aGVuIGludm9rZWQsIAphbmQgd3JhcHBpbmcgdGhhdCBpbnNpZGUgPGxpdGVyYWw+YmluZDwvbGl0ZXJhbD4gbWFrZXMgaXQgYSBsYW1iZGEgZnVuY3Rvci4KCkluIHRoZSBzYW1lIHdheSwgdGhlIGV4cHJlc3Npb24gPGxpdGVyYWw+ZGVsZXRlX3B0cigpPC9saXRlcmFsPiBjcmVhdGVzIAphIGZ1bmN0aW9uIG9iamVjdCB0aGF0IGludm9rZXMgPGxpdGVyYWw+ZGVsZXRlPC9saXRlcmFsPiBvbiBpdHMgYXJndW1lbnQuIAoKTm90ZSB0aGF0IDxsaXRlcmFsPm5ld19wdHImbHQ7PHBhcmFtZXRlcj5UPC9wYXJhbWV0ZXI+Jmd0OygpPC9saXRlcmFsPiAKY2FuIHRha2UgYXJndW1lbnRzIGFzIHdlbGwuCgpUaGV5IGFyZSBwYXNzZWQgZGlyZWN0bHkgdG8gdGhlIGNvbnN0cnVjdG9yIGludm9jYXRpb24gYW5kIHRodXMgYWxsb3cgCmNhbGxzIHRvIGNvbnN0cnVjdG9ycyB3aGljaCB0YWtlIGFyZ3VtZW50cy4gCgo8L3BhcmE+Cgo8cGFyYT4KCkFzIGFuIGV4YW1wbGUgb2YgY29uc3RydWN0b3IgY2FsbHMgaW4gbGFtYmRhIGV4cHJlc3Npb25zLCAKdGhlIGZvbGxvd2luZyBjb2RlIHJlYWRzIGludGVnZXJzIGZyb20gdHdvIGNvbnRhaW5lcnMgPGxpdGVyYWw+eDwvbGl0ZXJhbD4gCmFuZCA8bGl0ZXJhbD55PC9saXRlcmFsPiwgCmNvbnN0cnVjdHMgcGFpcnMgb3V0IG9mIHRoZW0gYW5kIGluc2VydHMgdGhlbSBpbnRvIGEgdGhpcmQgY29udGFpbmVyOgoKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVt2ZWN0b3I8cGFpcjxpbnQsIGludD4gPiB2Owp0cmFuc2Zvcm0oeC5iZWdpbigpLCB4LmVuZCgpLCB5LmJlZ2luKCksIGJhY2tfaW5zZXJ0ZXIodiksCiAgICAgICAgICBiaW5kKGNvbnN0cnVjdG9yPHBhaXI8aW50LCBpbnQ+ID4oKSwgXzEsIF8yKSk7XV0+CjwvcHJvZ3JhbWxpc3Rpbmc+Cgo8eHJlZiBsaW5rZW5kPSJ0YWJsZTpjb25zdHJ1Y3Rvcl9kZXN0cnVjdG9yX2ZvcyIvPiBsaXN0cyBhbGwgdGhlIGZ1bmN0aW9uIApvYmplY3RzIHJlbGF0ZWQgdG8gY3JlYXRpbmcgYW5kIGRlc3Ryb3lpbmcgb2JqZWN0cywKIHNob3dpbmcgdGhlIGV4cHJlc3Npb24gdG8gY3JlYXRlIGFuZCBjYWxsIHRoZSBmdW5jdGlvbiBvYmplY3QsIAphbmQgdGhlIGVmZmVjdCBvZiBldmFsdWF0aW5nIHRoYXQgZXhwcmVzc2lvbi4KCjwvcGFyYT4KCgoKPHRhYmxlIGlkPSJ0YWJsZTpjb25zdHJ1Y3Rvcl9kZXN0cnVjdG9yX2ZvcyI+Cjx0aXRsZT5Db25zdHJ1Y3Rpb24gYW5kIGRlc3RydWN0aW9uIHJlbGF0ZWQgZnVuY3Rpb24gb2JqZWN0cy48L3RpdGxlPgo8dGdyb3VwIGNvbHM9IjIiPgo8dGhlYWQ+Cjxyb3c+CjxlbnRyeT5GdW5jdGlvbiBvYmplY3QgY2FsbDwvZW50cnk+CjxlbnRyeT5XcmFwcGVkIGV4cHJlc3Npb248L2VudHJ5Pgo8L3Jvdz4KPC90aGVhZD4KPHRib2R5Pgo8cm93Pgo8ZW50cnk+PGxpdGVyYWw+Y29uc3RydWN0b3ImbHQ7VCZndDsoKSg8cGFyYW1ldGVyPmFyZ19saXN0PC9wYXJhbWV0ZXI+KTwvbGl0ZXJhbD48L2VudHJ5Pgo8ZW50cnk+VCg8cGFyYW1ldGVyPmFyZ19saXN0PC9wYXJhbWV0ZXI+KTwvZW50cnk+Cjwvcm93Pgo8cm93Pgo8ZW50cnk+PGxpdGVyYWw+ZGVzdHJ1Y3RvcigpKGEpPC9saXRlcmFsPjwvZW50cnk+CjxlbnRyeT48bGl0ZXJhbD5hLn5BKCk8L2xpdGVyYWw+LCB3aGVyZSA8bGl0ZXJhbD5hPC9saXRlcmFsPiBpcyBvZiB0eXBlIDxsaXRlcmFsPkE8L2xpdGVyYWw+PC9lbnRyeT4KPC9yb3c+Cjxyb3c+CjxlbnRyeT48bGl0ZXJhbD5kZXN0cnVjdG9yKCkocGEpPC9saXRlcmFsPjwvZW50cnk+CjxlbnRyeT48bGl0ZXJhbD5wYS0+fkEoKTwvbGl0ZXJhbD4sIHdoZXJlIDxsaXRlcmFsPnBhPC9saXRlcmFsPiBpcyBvZiB0eXBlIDxsaXRlcmFsPkEqPC9saXRlcmFsPjwvZW50cnk+Cjwvcm93Pgo8cm93Pgo8ZW50cnk+PGxpdGVyYWw+bmV3X3B0ciZsdDtUJmd0OygpKDxwYXJhbWV0ZXI+YXJnX2xpc3Q8L3BhcmFtZXRlcj4pPC9saXRlcmFsPjwvZW50cnk+CjxlbnRyeT48bGl0ZXJhbD5uZXcgVCg8cGFyYW1ldGVyPmFyZ19saXN0PC9wYXJhbWV0ZXI+KTwvbGl0ZXJhbD48L2VudHJ5Pgo8L3Jvdz4KPHJvdz4KPGVudHJ5PjxsaXRlcmFsPm5ld19hcnJheSZsdDtUJmd0OygpKHN6KTwvbGl0ZXJhbD48L2VudHJ5Pgo8ZW50cnk+PGxpdGVyYWw+bmV3IFRbc3pdPC9saXRlcmFsPjwvZW50cnk+Cjwvcm93Pgo8cm93Pgo8ZW50cnk+PGxpdGVyYWw+ZGVsZXRlX3B0cigpKHApPC9saXRlcmFsPjwvZW50cnk+CjxlbnRyeT48bGl0ZXJhbD5kZWxldGUgcDwvbGl0ZXJhbD48L2VudHJ5Pgo8L3Jvdz4KPHJvdz4KPGVudHJ5PjxsaXRlcmFsPmRlbGV0ZV9hcnJheSgpKHApPC9saXRlcmFsPjwvZW50cnk+CjxlbnRyeT48bGl0ZXJhbD5kZWxldGUgcFtdPC9saXRlcmFsPjwvZW50cnk+Cjwvcm93PgoKCjwvdGJvZHk+CjwvdGdyb3VwPgo8L3RhYmxlPiAKCjwvc2VjdGlvbj4KCgo8c2VjdGlvbj4KPHRpdGxlPlNwZWNpYWwgbGFtYmRhIGV4cHJlc3Npb25zPC90aXRsZT4KCjxzZWN0aW9uPgo8dGl0bGU+UHJldmVudGluZyBhcmd1bWVudCBzdWJzdGl0dXRpb248L3RpdGxlPgoKPHBhcmE+CldoZW4gYSBsYW1iZGEgZnVuY3RvciBpcyBjYWxsZWQsIHRoZSBkZWZhdWx0IGJlaGF2aW9yIGlzIHRvIHN1YnN0aXR1dGUgCnRoZSBhY3R1YWwgYXJndW1lbnRzIGZvciB0aGUgcGxhY2Vob2xkZXJzIHdpdGhpbiBhbGwgc3ViZXhwcmVzc2lvbnMuCgpUaGlzIHNlY3Rpb24gZGVzY3JpYmVzIHRoZSB0b29scyB0byBwcmV2ZW50IHRoZSBzdWJzdGl0dXRpb24gYW5kIApldmFsdWF0aW9uIG9mIGEgc3ViZXhwcmVzc2lvbiwgYW5kIGV4cGxhaW5zIHdoZW4gdGhlc2UgdG9vbHMgc2hvdWxkIGJlIHVzZWQuCjwvcGFyYT4KCgo8cGFyYT4KVGhlIGFyZ3VtZW50cyB0byBhIGJpbmQgZXhwcmVzc2lvbiBjYW4gYmUgYXJiaXRyYXJ5IGxhbWJkYSBleHByZXNzaW9ucywgCmUuZy4sIG90aGVyIGJpbmQgZXhwcmVzc2lvbnMuCgpGb3IgZXhhbXBsZToKCjxwcm9ncmFtbGlzdGluZz4KaW50IGZvbyhpbnQpOyBpbnQgYmFyKGludCk7Ci4uLgppbnQgaTsKYmluZChmb28sIGJpbmQoYmFyLCBfMSkpKGkpOwo8L3Byb2dyYW1saXN0aW5nPgoKVGhlIGxhc3QgbGluZSBtYWtlcyB0aGUgY2FsbCA8bGl0ZXJhbD5mb28oYmFyKGkpKTs8L2xpdGVyYWw+CgpOb3RlIHRoYXQgdGhlIGZpcnN0IGFyZ3VtZW50IGluIGEgYmluZCBleHByZXNzaW9uLCB0aGUgdGFyZ2V0IGZ1bmN0aW9uLCAKaXMgbm8gZXhjZXB0aW9uLCBhbmQgY2FuIHRodXMgYmUgYSBiaW5kIGV4cHJlc3Npb24gdG9vLgoKVGhlIGlubmVybW9zdCBsYW1iZGEgZnVuY3RvciBqdXN0IGhhcyB0byByZXR1cm4gc29tZXRoaW5nIHRoYXQgY2FuIGJlIHVzZWQgCmFzIGEgdGFyZ2V0IGZ1bmN0aW9uOiBhbm90aGVyIGxhbWJkYSBmdW5jdG9yLCBmdW5jdGlvbiBwb2ludGVyLCAKcG9pbnRlciB0byBtZW1iZXIgZnVuY3Rpb24gZXRjLiAKCkZvciBleGFtcGxlLCBpbiB0aGUgZm9sbG93aW5nIGNvZGUgdGhlIGlubmVybW9zdCBsYW1iZGEgZnVuY3RvciBtYWtlcyAKYSBzZWxlY3Rpb24gYmV0d2VlbiB0d28gZnVuY3Rpb25zLCBhbmQgcmV0dXJucyBhIHBvaW50ZXIgdG8gb25lIG9mIHRoZW06Cgo8cHJvZ3JhbWxpc3Rpbmc+CmludCBhZGQoaW50IGEsIGludCBiKSB7IHJldHVybiBhK2I7IH0KaW50IG11bChpbnQgYSwgaW50IGIpIHsgcmV0dXJuIGEqYjsgfQoKaW50KCopKGludCwgaW50KSAgYWRkX29yX211bChib29sIHgpIHsgCiAgcmV0dXJuIHggPyBhZGQgOiBtdWw7IAp9Cgpib29sIGNvbmRpdGlvbjsgaW50IGk7IGludCBqOwouLi4KYmluZChiaW5kKCZhbXA7YWRkX29yX211bCwgXzEpLCBfMiwgXzMpKGNvbmRpdGlvbiwgaSwgaik7CjwvcHJvZ3JhbWxpc3Rpbmc+Cgo8L3BhcmE+CgoKCjxzZWN0aW9uIGlkPSJsYW1iZGEudW5sYW1iZGEiPgo8dGl0bGU+VW5sYW1iZGE8L3RpdGxlPgoKPHBhcmE+QSBuZXN0ZWQgYmluZCBleHByZXNzaW9uIG1heSBvY2N1ciBpbmFkdmVydGVudGx5LCAKaWYgdGhlIHRhcmdldCBmdW5jdGlvbiBpcyBhIHZhcmlhYmxlIHdpdGggYSB0eXBlIHRoYXQgZGVwZW5kcyBvbiBhIAp0ZW1wbGF0ZSBwYXJhbWV0ZXIuIAoKVHlwaWNhbGx5IHRoZSB0YXJnZXQgZnVuY3Rpb24gY291bGQgYmUgYSBmb3JtYWwgcGFyYW1ldGVyIG9mIGEgCmZ1bmN0aW9uIHRlbXBsYXRlLiAKCkluIHN1Y2ggYSBjYXNlLCB0aGUgcHJvZ3JhbW1lciBtYXkgbm90IGtub3cgd2hldGhlciB0aGUgdGFyZ2V0IGZ1bmN0aW9uIGlzIGEgbGFtYmRhIGZ1bmN0b3Igb3Igbm90Lgo8L3BhcmE+Cgo8cGFyYT5Db25zaWRlciB0aGUgZm9sbG93aW5nIGZ1bmN0aW9uIHRlbXBsYXRlOgoKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVt0ZW1wbGF0ZTxjbGFzcyBGPgppbnQgbmVzdGVkKGNvbnN0IEYmIGYpIHsKICBpbnQgeDsKICAuLi4KICBiaW5kKGYsIF8xKSh4KTsKICAuLi4KfV1dPgo8L3Byb2dyYW1saXN0aW5nPgoKU29tZXdoZXJlIGluc2lkZSB0aGUgZnVuY3Rpb24gdGhlIGZvcm1hbCBwYXJhbWV0ZXIKPGxpdGVyYWw+ZjwvbGl0ZXJhbD4gaXMgdXNlZCBhcyBhIHRhcmdldCBmdW5jdGlvbiBpbiBhIGJpbmQgZXhwcmVzc2lvbi4gCgpJbiBvcmRlciBmb3IgdGhpcyA8bGl0ZXJhbD5iaW5kPC9saXRlcmFsPiBjYWxsIHRvIGJlIHZhbGlkLCAKPGxpdGVyYWw+ZjwvbGl0ZXJhbD4gbXVzdCBiZSBhIHVuYXJ5IGZ1bmN0aW9uLgoKU3VwcG9zZSB0aGUgZm9sbG93aW5nIHR3byBjYWxscyB0byA8bGl0ZXJhbD5uZXN0ZWQ8L2xpdGVyYWw+IGFyZSBtYWRlOgoKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVtpbnQgZm9vKGludCk7CmludCBiYXIoaW50LCBpbnQpOwpuZXN0ZWQoJmZvbyk7Cm5lc3RlZChiaW5kKGJhciwgMSwgXzEpKTtdXT4KPC9wcm9ncmFtbGlzdGluZz4KCkJvdGggYXJlIHVuYXJ5IGZ1bmN0aW9ucywgb3IgZnVuY3Rpb24gb2JqZWN0cywgd2l0aCBhcHByb3ByaWF0ZSBhcmd1bWVudCAKYW5kIHJldHVybiB0eXBlcywgYnV0IHRoZSBsYXR0ZXIgd2lsbCBub3QgY29tcGlsZS4KCkluIHRoZSBsYXR0ZXIgY2FsbCwgdGhlIGJpbmQgZXhwcmVzc2lvbiBpbnNpZGUgPGxpdGVyYWw+bmVzdGVkPC9saXRlcmFsPiAKd2lsbCBiZWNvbWU6Cgo8cHJvZ3JhbWxpc3Rpbmc+CmJpbmQoYmluZChiYXIsIDEsIF8xKSwgXzEpIAo8L3Byb2dyYW1saXN0aW5nPgoKV2hlbiB0aGlzIGlzIGludm9rZWQgd2l0aCA8bGl0ZXJhbD54PC9saXRlcmFsPiwgCmFmdGVyIHN1YnN0aXR1aXRpb25zIHdlIGVuZCB1cCB0cnlpbmcgdG8gY2FsbAoKPHByb2dyYW1saXN0aW5nPgpiYXIoMSwgeCkoeCkKPC9wcm9ncmFtbGlzdGluZz4KCndoaWNoIGlzIGFuIGVycm9yLiAKClRoZSBjYWxsIHRvIDxsaXRlcmFsPmJhcjwvbGl0ZXJhbD4gcmV0dXJucyBpbnQsIApub3QgYSB1bmFyeSBmdW5jdGlvbiBvciBmdW5jdGlvbiBvYmplY3QuCjwvcGFyYT4KCjxwYXJhPgpJbiB0aGUgZXhhbXBsZSBhYm92ZSwgdGhlIGludGVudCBvZiB0aGUgYmluZCBleHByZXNzaW9uIGluIHRoZSAKPGxpdGVyYWw+bmVzdGVkPC9saXRlcmFsPiBmdW5jdGlvbiBpcyB0byB0cmVhdCA8bGl0ZXJhbD5mPC9saXRlcmFsPiAKYXMgYW4gb3JkaW5hcnkgZnVuY3Rpb24gb2JqZWN0LCBpbnN0ZWFkIG9mIGEgbGFtYmRhIGZ1bmN0b3IuIAoKVGhlIEJMTCBwcm92aWRlcyB0aGUgZnVuY3Rpb24gdGVtcGxhdGUgPGxpdGVyYWw+dW5sYW1iZGE8L2xpdGVyYWw+IHRvIApleHByZXNzIHRoaXM6IGEgbGFtYmRhIGZ1bmN0b3Igd3JhcHBlZCBpbnNpZGUgPGxpdGVyYWw+dW5sYW1iZGE8L2xpdGVyYWw+IAppcyBub3QgYSBsYW1iZGEgZnVuY3RvciBhbnltb3JlLCBhbmQgZG9lcyBub3QgdGFrZSBwYXJ0IGludG8gdGhlIAphcmd1bWVudCBzdWJzdGl0dXRpb24gcHJvY2Vzcy4KCk5vdGUgdGhhdCBmb3IgYWxsIG90aGVyIGFyZ3VtZW50IHR5cGVzIDxsaXRlcmFsPnVubGFtYmRhPC9saXRlcmFsPiBpcyAKYW4gaWRlbnRpdHkgb3BlcmF0aW9uLCBleGNlcHQgZm9yIG1ha2luZyBub24tY29uc3Qgb2JqZWN0cyBjb25zdC4KPC9wYXJhPgoKPHBhcmE+ClVzaW5nIDxsaXRlcmFsPnVubGFtYmRhPC9saXRlcmFsPiwgdGhlIDxsaXRlcmFsPm5lc3RlZDwvbGl0ZXJhbD4gCmZ1bmN0aW9uIGlzIHdyaXR0ZW4gYXM6Cgo8cHJvZ3JhbWxpc3Rpbmc+CjwhW0NEQVRBW3RlbXBsYXRlPGNsYXNzIEY+CmludCBuZXN0ZWQoY29uc3QgRiYgZikgewogIGludCB4OwogIC4uLgogIGJpbmQodW5sYW1iZGEoZiksIF8xKSh4KTsKICAuLi4KfV1dPgo8L3Byb2dyYW1saXN0aW5nPgoKPC9wYXJhPgoKPC9zZWN0aW9uPgoKPHNlY3Rpb24+Cjx0aXRsZT5Qcm90ZWN0PC90aXRsZT4KCjxwYXJhPgpUaGUgPGxpdGVyYWw+cHJvdGVjdDwvbGl0ZXJhbD4gZnVuY3Rpb24gaXMgcmVsYXRlZCB0byB1bmxhbWJkYS4gCgpJdCBpcyBhbHNvIHVzZWQgdG8gcHJldmVudCB0aGUgYXJndW1lbnQgc3Vic3RpdHV0aW9uIHRha2luZyBwbGFjZSwgCmJ1dCB3aGVyZWFzIDxsaXRlcmFsPnVubGFtYmRhPC9saXRlcmFsPiB0dXJucyBhIGxhbWJkYSBmdW5jdG9yIGludG8gCmFuIG9yZGluYXJ5IGZ1bmN0aW9uIG9iamVjdCBmb3IgZ29vZCwgPGxpdGVyYWw+cHJvdGVjdDwvbGl0ZXJhbD4gZG9lcyAKdGhpcyB0ZW1wb3JhcmlseSwgZm9yIGp1c3Qgb25lIGV2YWx1YXRpb24gcm91bmQuCgpGb3IgZXhhbXBsZToKCjxwcm9ncmFtbGlzdGluZz4KaW50IHggPSAxLCB5ID0gMTA7CihfMSArIHByb3RlY3QoXzEgKyAyKSkoeCkoeSk7CjwvcHJvZ3JhbWxpc3Rpbmc+CiAgICAKVGhlIGZpcnN0IGNhbGwgc3Vic3RpdHV0ZXMgPGxpdGVyYWw+eDwvbGl0ZXJhbD4gZm9yIHRoZSBsZWZ0bW9zdCAKPGxpdGVyYWw+XzE8L2xpdGVyYWw+LCBhbmQgcmVzdWx0cyBpbiBhbm90aGVyIGxhbWJkYSBmdW5jdG9yIAo8bGl0ZXJhbD54ICsgKF8xICsgMik8L2xpdGVyYWw+LCB3aGljaCBhZnRlciB0aGUgY2FsbCB3aXRoIAo8bGl0ZXJhbD55PC9saXRlcmFsPiBiZWNvbWVzIDxsaXRlcmFsPnggKyAoeSArIDIpPC9saXRlcmFsPiwgCmFuZCB0aHVzIGZpbmFsbHkgMTMuCjwvcGFyYT4KCjxwYXJhPgpQcmltYXJ5IG1vdGl2YXRpb24gZm9yIGluY2x1ZGluZyA8bGl0ZXJhbD5wcm90ZWN0PC9saXRlcmFsPiBpbnRvIHRoZSBsaWJyYXJ5LCAKd2FzIHRvIGFsbG93IG5lc3RlZCBTVEwgYWxnb3JpdGhtIGludm9jYXRpb25zIAooPHhyZWYgbGlua2VuZD0ibGFtYmRhLm5lc3RlZF9zdGxfYWxnb3JpdGhtcyIvPikuCjwvcGFyYT4KCjwvc2VjdGlvbj4KCjwvc2VjdGlvbj4KCjxzZWN0aW9uIGlkPSJsYW1iZGEucnZhbHVlc19hc19hY3R1YWxfYXJndW1lbnRzIj4KPHRpdGxlPlJ2YWx1ZXMgYXMgYWN0dWFsIGFyZ3VtZW50cyB0byBsYW1iZGEgZnVuY3RvcnM8L3RpdGxlPgoKPCEtLSAgICAgIDxwYXJhPjxlbXBoYXNpcz5UaGlzIHNlY3Rpb24gYW5kIGFsbCBvZiBpdHMgc3Vic2VjdGlvbnMKICAgICAgIGFyZSBubyBsb25nZXIgKG9yIGN1cnJlbnRseSkgcmVsZXZhbnQ7CiAgICAgICBhY3VhbCBhcmd1bWVudHMgY2FuIGJlIG5vbi1jb25zdCBydmFsdWVzIGFuZCB0aGVzZSB3b3JrYXJvdW5kcyBhcmUgdGh1cwogICAgICAgbm90IG5lZWRlZC4KICAgICAgIFRoZSBzZWN0aW9uIGNhbiwgaG93ZXZlciwgYmVjb21lIHJlbGV2YW50IGFnYWluLCBpZiBpbiB0aGUgZnV0dXJlIEJMTCB3aWxsIHN1cHBvcnQKICAgICAgIGxhbWJkYSBmdW5jdG9ycyB3aXRoIGhpZ2hlciBhcml0aWVzIHRoYW4gMy48L2VtcGhhc2lzPjwvcGFyYT4gLS0+Cgo8cGFyYT4KQWN0dWFsIGFyZ3VtZW50cyB0byB0aGUgbGFtYmRhIGZ1bmN0b3JzIGNhbm5vdCBiZSBub24tY29uc3QgcnZhbHVlcy4KVGhpcyBpcyBkdWUgdG8gYSBkZWxpYmVyYXRlIGRlc2lnbiBkZWNpc2lvbjogZWl0aGVyIHdlIGhhdmUgdGhpcyByZXN0cmljdGlvbiwgCm9yIHRoZXJlIGNhbiBiZSBubyBzaWRlLWVmZmVjdHMgdG8gdGhlIGFjdHVhbCBhcmd1bWVudHMuCgpUaGVyZSBhcmUgd2F5cyBhcm91bmQgdGhpcyBsaW1pdGF0aW9uLgoKV2UgcmVwZWF0IHRoZSBleGFtcGxlIGZyb20gc2VjdGlvbiAKPHhyZWYgbGlua2VuZD0ibGFtYmRhLmFjdHVhbF9hcmd1bWVudHNfdG9fbGFtYmRhX2Z1bmN0b3JzIi8+IGFuZCBsaXN0IHRoZSAKZGlmZmVyZW50IHNvbHV0aW9uczoKCjxwcm9ncmFtbGlzdGluZz4KaW50IGkgPSAxOyBpbnQgaiA9IDI7IAooXzEgKyBfMikoaSwgaik7IC8vIG9rCihfMSArIF8yKSgxLCAyKTsgLy8gZXJyb3IgKCEpCjwvcHJvZ3JhbWxpc3Rpbmc+Cgo8b3JkZXJlZGxpc3Q+CjxsaXN0aXRlbT4KPHBhcmE+CklmIHRoZSBydmFsdWUgaXMgb2YgYSBjbGFzcyB0eXBlLCB0aGUgcmV0dXJuIHR5cGUgb2YgdGhlIGZ1bmN0aW9uIHRoYXQgCmNyZWF0ZXMgdGhlIHJ2YWx1ZSBzaG91bGQgYmUgZGVmaW5lZCBhcyBjb25zdC4gCkR1ZSB0byBhbiB1bmZvcnR1bmF0ZSBsYW5ndWFnZSByZXN0cmljdGlvbiB0aGlzIGRvZXMgbm90IHdvcmsgZm9yIApidWlsdC1pbiB0eXBlcywgYXMgYnVpbHQtaW4gcnZhbHVlcyBjYW5ub3QgYmUgY29uc3QgcXVhbGlmaWVkLiAKPC9wYXJhPgo8L2xpc3RpdGVtPgoKPGxpc3RpdGVtPgo8cGFyYT4KSWYgdGhlIGxhbWJkYSBmdW5jdGlvbiBjYWxsIGlzIGFjY2Vzc2libGUsIHRoZSA8bGl0ZXJhbD5tYWtlX2NvbnN0PC9saXRlcmFsPiAKZnVuY3Rpb24gY2FuIGJlIHVzZWQgdG8gPGVtcGhhc2lzPmNvbnN0aWZ5PC9lbXBoYXNpcz4gdGhlIHJ2YWx1ZS4gRS5nLjoKCjxwcm9ncmFtbGlzdGluZz4KKF8xICsgXzIpKG1ha2VfY29uc3QoMSksIG1ha2VfY29uc3QoMikpOyAvLyBvawo8L3Byb2dyYW1saXN0aW5nPgoKQ29tbW9ubHkgdGhlIGxhbWJkYSBmdW5jdGlvbiBjYWxsIHNpdGUgaXMgaW5zaWRlIGEgc3RhbmRhcmQgYWxnb3JpdGhtIApmdW5jdGlvbiB0ZW1wbGF0ZSwgcHJldmVudGluZyB0aGlzIHNvbHV0aW9uIHRvIGJlIHVzZWQuCgo8L3BhcmE+CjwvbGlzdGl0ZW0+Cgo8bGlzdGl0ZW0+CjxwYXJhPgpJZiBuZWl0aGVyIG9mIHRoZSBhYm92ZSBpcyBwb3NzaWJsZSwgdGhlIGxhbWJkYSBleHByZXNzaW9uIGNhbiBiZSB3cmFwcGVkIAppbiBhIDxsaXRlcmFsPmNvbnN0X3BhcmFtZXRlcnM8L2xpdGVyYWw+IGZ1bmN0aW9uLiAKSXQgY3JlYXRlcyBhbm90aGVyIHR5cGUgb2YgbGFtYmRhIGZ1bmN0b3IsIHdoaWNoIHRha2VzIGl0cyBhcmd1bWVudHMgYXMgCmNvbnN0IHJlZmVyZW5jZXMuIEZvciBleGFtcGxlOgoKPHByb2dyYW1saXN0aW5nPgpjb25zdF9wYXJhbWV0ZXJzKF8xICsgXzIpKDEsIDIpOyAvLyBvawo8L3Byb2dyYW1saXN0aW5nPgoKTm90ZSB0aGF0IDxsaXRlcmFsPmNvbnN0X3BhcmFtZXRlcnM8L2xpdGVyYWw+IG1ha2VzIGFsbCBhcmd1bWVudHMgY29uc3QuCkhlbmNlLCBpbiB0aGUgY2FzZSB3ZXJlIG9uZSBvZiB0aGUgYXJndW1lbnRzIGlzIGEgbm9uLWNvbnN0IHJ2YWx1ZSwgCmFuZCBhbm90aGVyIGFyZ3VtZW50IG5lZWRzIHRvIGJlIHBhc3NlZCBhcyBhIG5vbi1jb25zdCByZWZlcmVuY2UsIAp0aGlzIGFwcHJvYWNoIGNhbm5vdCBiZSB1c2VkLgo8L3BhcmE+Cgo8L2xpc3RpdGVtPgoKPGxpc3RpdGVtPgo8cGFyYT5JZiBub25lIG9mIHRoZSBhYm92ZSBpcyBwb3NzaWJsZSwgdGhlcmUgaXMgc3RpbGwgb25lIHNvbHV0aW9uLCAKd2hpY2ggdW5mb3J0dW5hdGVseSBjYW4gYnJlYWsgY29uc3QgY29ycmVjdG5lc3MuCgpUaGUgc29sdXRpb24gaXMgeWV0IGFub3RoZXIgbGFtYmRhIGZ1bmN0b3Igd3JhcHBlciwgd2hpY2ggd2UgaGF2ZSBuYW1lZCAKPGxpdGVyYWw+YnJlYWtfY29uc3Q8L2xpdGVyYWw+IHRvIGFsZXJ0IHRoZSB1c2VyIG9mIHRoZSBwb3RlbnRpYWwgZGFuZ2VycyAKb2YgdGhpcyBmdW5jdGlvbi4gCgpUaGUgPGxpdGVyYWw+YnJlYWtfY29uc3Q8L2xpdGVyYWw+IGZ1bmN0aW9uIGNyZWF0ZXMgYSBsYW1iZGEgZnVuY3RvciB0aGF0IAp0YWtlcyBpdHMgYXJndW1lbnRzIGFzIGNvbnN0LCBhbmQgY2FzdHMgYXdheSBjb25zdG5lc3MgcHJpb3IgdG8gdGhlIGNhbGwgCnRvIHRoZSBvcmlnaW5hbCB3cmFwcGVkIGxhbWJkYSBmdW5jdG9yLgoKRm9yIGV4YW1wbGU6Cjxwcm9ncmFtbGlzdGluZz4KaW50IGk7IAouLi4KKF8xICs9IF8yKShpLCAyKTsgICAgICAgICAgICAgICAgIC8vIGVycm9yLCAyIGlzIGEgbm9uLWNvbnN0IHJ2YWx1ZQpjb25zdF9wYXJhbWV0ZXJzKF8xICs9IF8yKShpLCAyKTsgLy8gZXJyb3IsIGkgYmVjb21lcyBjb25zdApicmVha19jb25zdChfMSArPSBfMikoaSwgMik7ICAgICAgLy8gb2ssIGJ1dCBkYW5nZXJvdXMKPC9wcm9ncmFtbGlzdGluZz4KCk5vdGUsIHRoYXQgdGhlIHJlc3VsdHMgb2YgPGxpdGVyYWw+IGJyZWFrX2NvbnN0PC9saXRlcmFsPiBvciAKPGxpdGVyYWw+Y29uc3RfcGFyYW1ldGVyczwvbGl0ZXJhbD4gYXJlIG5vdCBsYW1iZGEgZnVuY3RvcnMsIApzbyB0aGV5IGNhbm5vdCBiZSB1c2VkIGFzIHN1YmV4cHJlc3Npb25zIG9mIGxhbWJkYSBleHByZXNzaW9ucy4gRm9yIGluc3RhbmNlOgoKPHByb2dyYW1saXN0aW5nPgpicmVha19jb25zdChfMSArIF8yKSArIF8zOyAvLyBmYWlscy4KY29uc3RfcGFyYW1ldGVycyhfMSArIF8yKSArIF8zOyAvLyBmYWlscy4KPC9wcm9ncmFtbGlzdGluZz4KCkhvd2V2ZXIsIHRoaXMga2luZCBvZiBjb2RlIHNob3VsZCBuZXZlciBiZSBuZWNlc3NhcnksIApzaW5jZSBjYWxscyB0byBzdWIgbGFtYmRhIGZ1bmN0b3JzIGFyZSBtYWRlIGluc2lkZSB0aGUgQkxMLCAKYW5kIGFyZSBub3QgYWZmZWN0ZWQgYnkgdGhlIG5vbi1jb25zdCBydmFsdWUgcHJvYmxlbS4KPC9wYXJhPgo8L2xpc3RpdGVtPgoKPC9vcmRlcmVkbGlzdD4KCjwvcGFyYT4KPC9zZWN0aW9uPgoKPC9zZWN0aW9uPgoKCjxzZWN0aW9uPgo8dGl0bGU+Q2FzdHMsIHNpemVvZiBhbmQgdHlwZWlkPC90aXRsZT4KCjxzZWN0aW9uIGlkPSJsYW1iZGEuY2FzdF9leHByZXNzaW9ucyI+Cjx0aXRsZT4KQ2FzdCBleHByZXNzaW9ucwo8L3RpdGxlPgo8cGFyYT4KVGhlIEJMTCBkZWZpbmVzIGl0cyBjb3VudGVycGFydHMgZm9yIHRoZSBmb3VyIGNhc3QgZXhwcmVzc2lvbnMgCjxsaXRlcmFsPnN0YXRpY19jYXN0PC9saXRlcmFsPiwgPGxpdGVyYWw+ZHluYW1pY19jYXN0PC9saXRlcmFsPiwgCjxsaXRlcmFsPmNvbnN0X2Nhc3Q8L2xpdGVyYWw+IGFuZCA8bGl0ZXJhbD5yZWludGVycHJldF9jYXN0PC9saXRlcmFsPi4KClRoZSBCTEwgdmVyc2lvbnMgb2YgdGhlIGNhc3QgZXhwcmVzc2lvbnMgaGF2ZSB0aGUgcHJlZml4IAo8bGl0ZXJhbD5sbF88L2xpdGVyYWw+LgoKVGhlIHR5cGUgdG8gY2FzdCB0byBpcyBnaXZlbiBhcyBhbiBleHBsaWNpdGx5IHNwZWNpZmllZCB0ZW1wbGF0ZSBhcmd1bWVudCwgCmFuZCB0aGUgc29sZSBhcmd1bWVudCBpcyB0aGUgZXhwcmVzc2lvbiBmcm9tIHdoaWNoIHRvIHBlcmZvcm0gdGhlIGNhc3QuCgpJZiB0aGUgYXJndW1lbnQgaXMgYSBsYW1iZGEgZnVuY3RvciwgdGhlIGxhbWJkYSBmdW5jdG9yIGlzIGV2YWx1YXRlZCBmaXJzdC4KCkZvciBleGFtcGxlLCB0aGUgZm9sbG93aW5nIGNvZGUgdXNlcyA8bGl0ZXJhbD5sbF9keW5hbWljX2Nhc3Q8L2xpdGVyYWw+IAp0byBjb3VudCB0aGUgbnVtYmVyIG9mIDxsaXRlcmFsPmRlcml2ZWQ8L2xpdGVyYWw+IGluc3RhbmNlcyBpbiB0aGUgY29udGFpbmVyIAo8bGl0ZXJhbD5hPC9saXRlcmFsPjoKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbY2xhc3MgYmFzZSB7fTsKY2xhc3MgZGVyaXZlZCA6IHB1YmxpYyBiYXNlIHt9OwoKdmVjdG9yPGJhc2UqPiBhOwouLi4KaW50IGNvdW50ID0gMDsKZm9yX2VhY2goYS5iZWdpbigpLCBhLmVuZCgpLCAKICAgICAgICAgaWZfdGhlbihsbF9keW5hbWljX2Nhc3Q8ZGVyaXZlZCo+KF8xKSwgKyt2YXIoY291bnQpKSk7XV0+CjwvcHJvZ3JhbWxpc3Rpbmc+CjwvcGFyYT4KPC9zZWN0aW9uPgoKPHNlY3Rpb24+Cjx0aXRsZT5TaXplb2YgYW5kIHR5cGVpZDwvdGl0bGU+CjxwYXJhPgpUaGUgQkxMIGNvdW50ZXJwYXJ0cyBmb3IgdGhlc2UgZXhwcmVzc2lvbnMgYXJlIG5hbWVkIAo8bGl0ZXJhbD5sbF9zaXplb2Y8L2xpdGVyYWw+IGFuZCA8bGl0ZXJhbD5sbF90eXBlaWQ8L2xpdGVyYWw+LgoKQm90aCB0YWtlIG9uZSBhcmd1bWVudCwgd2hpY2ggY2FuIGJlIGEgbGFtYmRhIGV4cHJlc3Npb24uClRoZSBsYW1iZGEgZnVuY3RvciBjcmVhdGVkIHdyYXBzIHRoZSA8bGl0ZXJhbD5zaXplb2Y8L2xpdGVyYWw+IG9yIAo8bGl0ZXJhbD50eXBlaWQ8L2xpdGVyYWw+IGNhbGwsIGFuZCB3aGVuIHRoZSBsYW1iZGEgZnVuY3RvciBpcyBjYWxsZWQgCnRoZSB3cmFwcGVkIG9wZXJhdGlvbiBpcyBwZXJmb3JtZWQuCgpGb3IgZXhhbXBsZToKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbdmVjdG9yPGJhc2UqPiBhOyAKLi4uCmZvcl9lYWNoKGEuYmVnaW4oKSwgYS5lbmQoKSwgCiAgICAgICAgIGNvdXQgPDwgYmluZCgmdHlwZV9pbmZvOjpuYW1lLCBsbF90eXBlaWQoKl8xKSkpO11dPgo8L3Byb2dyYW1saXN0aW5nPgoKSGVyZSA8bGl0ZXJhbD5sbF90eXBlaWQ8L2xpdGVyYWw+IGNyZWF0ZXMgYSBsYW1iZGEgZnVuY3RvciBmb3IgCmNhbGxpbmcgPGxpdGVyYWw+dHlwZWlkPC9saXRlcmFsPiBmb3IgZWFjaCBlbGVtZW50LgoKVGhlIHJlc3VsdCBvZiBhIDxsaXRlcmFsPnR5cGVpZDwvbGl0ZXJhbD4gY2FsbCBpcyBhbiBpbnN0YW5jZSBvZiAKdGhlIDxsaXRlcmFsPnR5cGVfaW5mbzwvbGl0ZXJhbD4gY2xhc3MsIGFuZCB0aGUgYmluZCBleHByZXNzaW9uIGNyZWF0ZXMgCmEgbGFtYmRhIGZ1bmN0b3IgZm9yIGNhbGxpbmcgdGhlIDxsaXRlcmFsPm5hbWU8L2xpdGVyYWw+IG1lbWJlciAKZnVuY3Rpb24gb2YgdGhhdCBjbGFzcy4KCjwvcGFyYT4KPC9zZWN0aW9uPgoKCgo8L3NlY3Rpb24+Cgo8c2VjdGlvbiBpZD0ibGFtYmRhLm5lc3RlZF9zdGxfYWxnb3JpdGhtcyI+Cjx0aXRsZT5OZXN0aW5nIFNUTCBhbGdvcml0aG0gaW52b2NhdGlvbnM8L3RpdGxlPgoKPHBhcmE+ClRoZSBCTEwgZGVmaW5lcyBjb21tb24gU1RMIGFsZ29yaXRobXMgYXMgZnVuY3Rpb24gb2JqZWN0IGNsYXNzZXMsIAppbnN0YW5jZXMgb2Ygd2hpY2ggY2FuIGJlIHVzZWQgYXMgdGFyZ2V0IGZ1bmN0aW9ucyBpbiBiaW5kIGV4cHJlc3Npb25zLgpGb3IgZXhhbXBsZSwgdGhlIGZvbGxvd2luZyBjb2RlIGl0ZXJhdGVzIG92ZXIgdGhlIGVsZW1lbnRzIG9mIGEgCnR3by1kaW1lbnNpb25hbCBhcnJheSwgYW5kIGNvbXB1dGVzIHRoZWlyIHN1bS4KCjxwcm9ncmFtbGlzdGluZz4KaW50IGFbMTAwXVsyMDBdOwppbnQgc3VtID0gMDsKCnN0ZDo6Zm9yX2VhY2goYSwgYSArIDEwMCwgCgkgICAgICBiaW5kKGxsOjpmb3JfZWFjaCgpLCBfMSwgXzEgKyAyMDAsIHByb3RlY3Qoc3VtICs9IF8xKSkpOwo8L3Byb2dyYW1saXN0aW5nPgoKVGhlIEJMTCB2ZXJzaW9ucyBvZiB0aGUgU1RMIGFsZ29yaXRobXMgYXJlIGNsYXNzZXMsIHdoaWNoIGRlZmluZSB0aGUgZnVuY3Rpb24gY2FsbCBvcGVyYXRvciAob3Igc2V2ZXJhbCBvdmVybG9hZGVkIG9uZXMpIHRvIGNhbGwgdGhlIGNvcnJlc3BvbmRpbmcgZnVuY3Rpb24gdGVtcGxhdGVzIGluIHRoZSA8bGl0ZXJhbD5zdGQ8L2xpdGVyYWw+IG5hbWVzcGFjZS4KQWxsIHRoZXNlIHN0cnVjdHMgYXJlIHBsYWNlZCBpbiB0aGUgc3VibmFtZXNwYWNlIDxsaXRlcmFsPmJvb3N0OjpsYW1iZGE6bGw8L2xpdGVyYWw+LiAKPCEtLVRoZSBzdXBwb3J0ZWQgYWxnb3JpdGhtcyBhcmUgbGlzdGVkIGluIDx4cmVmIGxpbmtlbmQ9InRhYmxlOm5lc3RlZF9hbGdvcml0aG1zIi8+Li0tPgo8L3BhcmE+Cgo8cGFyYT4KTm90ZSB0aGF0IHRoZXJlIGlzIG5vIGVhc3kgd2F5IHRvIGV4cHJlc3MgYW4gb3ZlcmxvYWRlZCBtZW1iZXIgZnVuY3Rpb24gCmNhbGwgaW4gYSBsYW1iZGEgZXhwcmVzc2lvbi4gCgpUaGlzIGxpbWl0cyB0aGUgdXNlZnVsbmVzcyBvZiBuZXN0ZWQgU1RMIGFsZ29yaXRobXMsIGFzIGZvciBpbnN0YW5jZSAKdGhlIDxsaXRlcmFsPmJlZ2luPC9saXRlcmFsPiBmdW5jdGlvbiBoYXMgbW9yZSB0aGFuIG9uZSBvdmVybG9hZGVkIApkZWZpbml0aW9ucyBpbiBjb250YWluZXIgdGVtcGxhdGVzLgoKSW4gZ2VuZXJhbCwgc29tZXRoaW5nIGFuYWxvZ291cyB0byB0aGUgcHNldWRvLWNvZGUgYmVsb3cgY2Fubm90IGJlIHdyaXR0ZW46Cgo8cHJvZ3JhbWxpc3Rpbmc+CnN0ZDo6Zm9yX2VhY2goYS5iZWdpbigpLCBhLmVuZCgpLCAKCSAgICAgIGJpbmQobGw6OmZvcl9lYWNoKCksIF8xLmJlZ2luKCksIF8xLmVuZCgpLCBwcm90ZWN0KHN1bSArPSBfMSkpKTsKPC9wcm9ncmFtbGlzdGluZz4KClNvbWUgYWlkIGZvciBjb21tb24gc3BlY2lhbCBjYXNlcyBjYW4gYmUgcHJvdmlkZWQgdGhvdWdoLgoKVGhlIEJMTCBkZWZpbmVzIHR3byBoZWxwZXIgZnVuY3Rpb24gb2JqZWN0IGNsYXNzZXMsIAo8bGl0ZXJhbD5jYWxsX2JlZ2luPC9saXRlcmFsPiBhbmQgPGxpdGVyYWw+Y2FsbF9lbmQ8L2xpdGVyYWw+LCAKd2hpY2ggd3JhcCBhIGNhbGwgdG8gdGhlIDxsaXRlcmFsPmJlZ2luPC9saXRlcmFsPiBhbmQsIHJlc3BlY3RpdmVseSwgCjxsaXRlcmFsPmVuZDwvbGl0ZXJhbD4gZnVuY3Rpb25zIG9mIGEgY29udGFpbmVyLCBhbmQgcmV0dXJuIHRoZSAKPGxpdGVyYWw+Y29uc3RfaXRlcmF0b3I8L2xpdGVyYWw+IHR5cGUgb2YgdGhlIGNvbnRhaW5lci4KCldpdGggdGhlc2UgaGVscGVyIHRlbXBsYXRlcywgdGhlIGFib3ZlIGNvZGUgYmVjb21lczoKPHByb2dyYW1saXN0aW5nPgpzdGQ6OmZvcl9lYWNoKGEuYmVnaW4oKSwgYS5lbmQoKSwgCgkgICAgICBiaW5kKGxsOjpmb3JfZWFjaCgpLCAKICAgICAgICAgICAgICAgICAgIGJpbmQoY2FsbF9iZWdpbigpLCBfMSksIGJpbmQoY2FsbF9lbmQoKSwgXzEpLAogICAgICAgICAgICAgICAgICAgICAgICBwcm90ZWN0KHN1bSArPSBfMSkpKTsKPC9wcm9ncmFtbGlzdGluZz4KCjwvcGFyYT4KCjwhLS0KPHRhYmxlIGlkPSJ0YWJsZTpuZXN0ZWRfYWxnb3JpdGhtcyI+Cjx0aXRsZT5UaGUgbmVzdGVkIFNUTCBhbGdvcml0aG1zLjwvdGl0bGU+Cjx0Z3JvdXAgY29scz0iMSI+Cjx0aGVhZD4KPHRyb3c+PGVudHJ5Pk90c2lra288L2VudHJ5PjwvdHJvdz4KPC90aGVhZD4KPHRib2R5Pgo8cm93PjxlbnRyeT48bGl0ZXJhbD5mb3JfZWFjaDwvbGl0ZXJhbD48L2VudHJ5Pjwvcm93Pgo8cm93PjxlbnRyeT48bGl0ZXJhbD5maW5kPC9saXRlcmFsPjwvZW50cnk+PC9yb3c+Cjxyb3c+PGVudHJ5PjxsaXRlcmFsPmZpbmRfaWY8L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPHJvdz48ZW50cnk+PGxpdGVyYWw+ZmluZF9lbmQ8L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPHJvdz48ZW50cnk+PGxpdGVyYWw+ZmluZF9maXJzdF9vZjwvbGl0ZXJhbD48L2VudHJ5Pjwvcm93Pgo8cm93PjxlbnRyeT48bGl0ZXJhbD50cmFuc2Zvcm08L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPC90Ym9keT4KPC90Z3JvdXA+Cgo8L3RhYmxlPgoKLS0+Cgo8L3NlY3Rpb24+CgoKPC9zZWN0aW9uPgoKCjwhLS0KPHNlY3Rpb24+Cjx0aXRsZT5Db21tb24gZ290aGNhczwvdGl0bGU+CgpjYWxsaW5nIG1lbWJlciBmdW5jdGlvbnMgYS5iZWdpbigpIAoKY2FsbGluZyB0ZW1wbGF0ZWQgZnVuY3Rpb25zIC4uLgoKPC9zZWN0aW9uPgoKLS0+Cgo8c2VjdGlvbiBpZD0ibGFtYmRhLmV4dGVuZGluZyI+Cjx0aXRsZT5FeHRlbmRpbmcgcmV0dXJuIHR5cGUgZGVkdWN0aW9uIHN5c3RlbTwvdGl0bGU+Cgo8cGFyYT4KPCEtLVRoZSA8eHJlZiBsaW5rZW5kID0gImxhbWJkYS5vdmVycmlkaW5nX2RlZHVjZWRfcmV0dXJuX3R5cGUiLz4gc2hvd2VkIGhvdyB0byBtYWtlIEJMTCBhd2FyZSBvZiB0aGUgcmV0dXJuIHR5cGUgb2YgYSBmdW5jdGlvbiBvYmplY3QgaW4gYmluZCBleHByZXNzaW9ucy4tLT4KCkluIHRoaXMgc2VjdGlvbiwgd2UgZXhwbGFpbiAgaG93IHRvIGV4dGVuZCB0aGUgcmV0dXJuIHR5cGUgZGVkdWN0aW9uIHN5c3RlbSAKdG8gY292ZXIgdXNlciBkZWZpbmVkIG9wZXJhdG9ycy4gCgpJbiBtYW55IGNhc2VzIHRoaXMgaXMgbm90IG5lY2Vzc2FyeSwgCmFzIHRoZSBCTEwgZGVmaW5lcyBkZWZhdWx0IHJldHVybiB0eXBlcyBmb3Igb3BlcmF0b3JzLgoKRm9yIGV4YW1wbGUsIHRoZSBkZWZhdWx0IHJldHVybiB0eXBlIGZvciBhbGwgY29tcGFyaXNvbiBvcGVyYXRvcnMgaXMgCjxsaXRlcmFsPmJvb2w8L2xpdGVyYWw+LCBhbmQgYXMgbG9uZyBhcyB0aGUgdXNlciBkZWZpbmVkIGNvbXBhcmlzb24gb3BlcmF0b3JzIApoYXZlIGEgYm9vbCByZXR1cm4gdHlwZSwgdGhlcmUgaXMgbm8gbmVlZCB0byB3cml0ZSBuZXcgc3BlY2lhbGl6YXRpb25zIApmb3IgdGhlIHJldHVybiB0eXBlIGRlZHVjdGlvbiBjbGFzc2VzLgoKU29tZXRpbWVzIHRoaXMgY2Fubm90IGJlIGF2b2lkZWQsIHRob3VnaC4KCjwvcGFyYT4KCjxwYXJhPgpUaGUgb3ZlcmxvYWRhYmxlIHVzZXIgZGVmaW5lZCBvcGVyYXRvcnMgYXJlIGVpdGhlciB1bmFyeSBvciBiaW5hcnkuIAoKRm9yIGVhY2ggYXJpdHksIHRoZXJlIGFyZSB0d28gdHJhaXRzIHRlbXBsYXRlcyB0aGF0IGRlZmluZSB0aGUgCnJldHVybiB0eXBlcyBvZiB0aGUgZGlmZmVyZW50IG9wZXJhdG9ycy4KCkhlbmNlLCB0aGUgcmV0dXJuIHR5cGUgc3lzdGVtIGNhbiBiZSBleHRlbmRlZCBieSBwcm92aWRpbmcgbW9yZSAKc3BlY2lhbGl6YXRpb25zIGZvciB0aGVzZSB0ZW1wbGF0ZXMuCgpUaGUgdGVtcGxhdGVzIGZvciB1bmFyeSBmdW5jdG9ycyBhcmUKCjxsaXRlcmFsPgo8IVtDREFUQVtwbGFpbl9yZXR1cm5fdHlwZV8xPEFjdGlvbiwgQT5dXT4KPC9saXRlcmFsPgoKYW5kIAoKPGxpdGVyYWw+CjwhW0NEQVRBW3JldHVybl90eXBlXzE8QWN0aW9uLCBBPl1dPgo8L2xpdGVyYWw+LCBhbmQgCgo8bGl0ZXJhbD4KPCFbQ0RBVEFbcGxhaW5fcmV0dXJuX3R5cGVfMjxBY3Rpb24sIEEsIEI+XV0+CjwvbGl0ZXJhbD4KCmFuZCAKCjxsaXRlcmFsPgo8IVtDREFUQVtyZXR1cm5fdHlwZV8yPEFjdGlvbiwgQSwgQj5dXT4KPC9saXRlcmFsPgoKcmVzcGVjdGl2ZWx5IGZvciBiaW5hcnkgZnVuY3RvcnMuCgo8L3BhcmE+Cgo8cGFyYT4KVGhlIGZpcnN0IHBhcmFtZXRlciAoPGxpdGVyYWw+QWN0aW9uPC9saXRlcmFsPikgdG8gYWxsIHRoZXNlIHRlbXBsYXRlcyAKaXMgdGhlIDxlbXBoYXNpcz5hY3Rpb248L2VtcGhhc2lzPiBjbGFzcywgd2hpY2ggc3BlY2lmaWVzIHRoZSBvcGVyYXRvci4gCgpPcGVyYXRvcnMgd2l0aCBzaW1pbGFyIHJldHVybiB0eXBlIHJ1bGVzIGFyZSBncm91cGVkIHRvZ2V0aGVyIGludG8gCjxlbXBoYXNpcz5hY3Rpb24gZ3JvdXBzPC9lbXBoYXNpcz4sIAphbmQgb25seSB0aGUgYWN0aW9uIGNsYXNzIGFuZCBhY3Rpb24gZ3JvdXAgdG9nZXRoZXIgZGVmaW5lIHRoZSBvcGVyYXRvciAKdW5hbWJpZ3VvdXNseS4gCgpBcyBhbiBleGFtcGxlLCB0aGUgYWN0aW9uIHR5cGUgCjxsaXRlcmFsPjwhW0NEQVRBW2FyaXRobWV0aWNfYWN0aW9uPHBsdXNfYWN0aW9uPl1dPjwvbGl0ZXJhbD4gc3RhbmRzIGZvciAKPGxpdGVyYWw+b3BlcmF0b3IrPC9saXRlcmFsPi4gCgpUaGUgY29tcGxldGUgbGlzdGluZyBvZiBkaWZmZXJlbnQgYWN0aW9uIHR5cGVzIGlzIHNob3duIGluIAo8eHJlZiBsaW5rZW5kPSJ0YWJsZTphY3Rpb25zIi8+LiAKPC9wYXJhPgoKPHBhcmE+ClRoZSBsYXR0ZXIgcGFyYW1ldGVycywgPGxpdGVyYWw+QTwvbGl0ZXJhbD4gaW4gdGhlIHVuYXJ5IGNhc2UsIApvciA8bGl0ZXJhbD5BPC9saXRlcmFsPiBhbmQgPGxpdGVyYWw+QjwvbGl0ZXJhbD4gaW4gdGhlIGJpbmFyeSBjYXNlLCAKc3RhbmQgZm9yIHRoZSBhcmd1bWVudCB0eXBlcyBvZiB0aGUgb3BlcmF0b3IgY2FsbC4gCgpUaGUgdHdvIHNldHMgb2YgdGVtcGxhdGVzLCAKPGxpdGVyYWw+cGxhaW5fcmV0dXJuX3R5cGVfPHBhcmFtZXRlcj5uPC9wYXJhbWV0ZXI+PC9saXRlcmFsPiBhbmQgCjxsaXRlcmFsPnJldHVybl90eXBlXzxwYXJhbWV0ZXI+bjwvcGFyYW1ldGVyPjwvbGl0ZXJhbD4gCig8cGFyYW1ldGVyPm48L3BhcmFtZXRlcj4gaXMgMSBvciAyKSBkaWZmZXIgaW4gdGhlIHdheSBob3cgcGFyYW1ldGVyIHR5cGVzIAphcmUgcHJlc2VudGVkIHRvIHRoZW0uCgpGb3IgdGhlIGZvcm1lciB0ZW1wbGF0ZXMsIHRoZSBwYXJhbWV0ZXIgdHlwZXMgYXJlIGFsd2F5cyBwcm92aWRlZCBhcyAKbm9uLXJlZmVyZW5jZSB0eXBlcywgYW5kIGRvIG5vdCBoYXZlIGNvbnN0IG9yIHZvbGF0aWxlIHF1YWxpZmllcnMuCgpUaGlzIG1ha2VzIHNwZWNpYWxpemluZyBlYXN5LCBhcyBjb21tb25seSBvbmUgc3BlY2lhbGl6YXRpb24gZm9yIGVhY2ggCnVzZXIgZGVmaW5lZCBvcGVyYXRvciwgb3Igb3BlcmF0b3IgZ3JvdXAsIGlzIGVub3VnaC4KCk9uIHRoZSBvdGhlciBoYW5kLCBpZiBhIHBhcnRpY3VsYXIgb3BlcmF0b3IgaXMgb3ZlcmxvYWRlZCBmb3IgZGlmZmVyZW50IApjdi1xdWFsaWZpY2F0aW9ucyBvZiB0aGUgc2FtZSBhcmd1bWVudCB0eXBlcywgCmFuZCB0aGUgcmV0dXJuIHR5cGVzIG9mIHRoZXNlIG92ZXJsb2FkZWQgdmVyc2lvbnMgZGlmZmVyLCBhIG1vcmUgZmluZS1ncmFpbmVkIGNvbnRyb2wgaXMgbmVlZGVkLgoKSGVuY2UsIGZvciB0aGUgbGF0dGVyIHRlbXBsYXRlcywgdGhlIHBhcmFtZXRlciB0eXBlcyBwcmVzZXJ2ZSB0aGUgCmN2LXF1YWxpZmllcnMsIGFuZCBhcmUgbm9uLXJlZmVyZW5jZSB0eXBlcyBhcyB3ZWxsLiAKIApUaGUgZG93bnNpZGUgaXMsIHRoYXQgZm9yIGFuIG92ZXJsb2FkZWQgc2V0IG9mIG9wZXJhdG9ycyBvZiB0aGUgCmtpbmQgZGVzY3JpYmVkIGFib3ZlLCBvbmUgbWF5IGVuZCB1cCBuZWVkaW5nIHVwIHRvIAoxNiA8bGl0ZXJhbD5yZXR1cm5fdHlwZV8yPC9saXRlcmFsPiBzcGVjaWFsaXphdGlvbnMuCjwvcGFyYT4KCjxwYXJhPgpTdXBwb3NlIHRoZSB1c2VyIGhhcyBvdmVybG9hZGVkIHRoZSBmb2xsb3dpbmcgb3BlcmF0b3JzIGZvciBzb21lIHVzZXIgZGVmaW5lZCAKdHlwZXMgPGxpdGVyYWw+WDwvbGl0ZXJhbD4sIDxsaXRlcmFsPlk8L2xpdGVyYWw+IGFuZCA8bGl0ZXJhbD5aPC9saXRlcmFsPjoKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbWiBvcGVyYXRvcisoY29uc3QgWCYsIGNvbnN0IFkmKTsKWiBvcGVyYXRvci0oY29uc3QgWCYsIGNvbnN0IFkmKTtdXT4KPC9wcm9ncmFtbGlzdGluZz4KCk5vdywgb25lIGNhbiBhZGQgYSBzcGVjaWFsaXphdGlvbiBzdGF0aW5nLCB0aGF0IGlmIHRoZSBsZWZ0IGhhbmQgYXJndW1lbnQgCmlzIG9mIHR5cGUgPGxpdGVyYWw+WDwvbGl0ZXJhbD4sIGFuZCB0aGUgcmlnaHQgaGFuZCBvbmUgb2YgdHlwZSAKPGxpdGVyYWw+WTwvbGl0ZXJhbD4sIHRoZSByZXR1cm4gdHlwZSBvZiBhbGwgc3VjaCBiaW5hcnkgYXJpdGhtZXRpYyAKb3BlcmF0b3JzIGlzIDxsaXRlcmFsPlo8L2xpdGVyYWw+OgoKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVtuYW1lc3BhY2UgYm9vc3QgeyAKbmFtZXNwYWNlIGxhbWJkYSB7CiAgCnRlbXBsYXRlPGNsYXNzIEFjdD4gCnN0cnVjdCBwbGFpbl9yZXR1cm5fdHlwZV8yPGFyaXRobWV0aWNfYWN0aW9uPEFjdD4sIFgsIFk+IHsKICB0eXBlZGVmIFogdHlwZTsKfTsKCn0KfV1dPgo8L3Byb2dyYW1saXN0aW5nPgoKSGF2aW5nIHRoaXMgc3BlY2lhbGl6YXRpb24gZGVmaW5lZCwgQkxMIGlzIGNhcGFibGUgb2YgY29ycmVjdGx5IApkZWR1Y2luZyB0aGUgcmV0dXJuIHR5cGUgb2YgdGhlIGFib3ZlIHR3byBvcGVyYXRvcnMuCgpOb3RlLCB0aGF0IHRoZSBzcGVjaWFsaXphdGlvbnMgbXVzdCBiZSBpbiB0aGUgc2FtZSBuYW1lc3BhY2UsIAo8bGl0ZXJhbD46OmJvb3N0OjpsYW1iZGE8L2xpdGVyYWw+LCB3aXRoIHRoZSBwcmltYXJ5IHRlbXBsYXRlLiAKCkZvciBicmV2aXR5LCB3ZSBkbyBub3Qgc2hvdyB0aGUgbmFtZXNwYWNlIGRlZmluaXRpb25zIGluIHRoZSBleGFtcGxlcyBiZWxvdy4KPC9wYXJhPgoKPHBhcmE+Ckl0IGlzIHBvc3NpYmxlIHRvIHNwZWNpYWxpemUgb24gdGhlIGxldmVsIG9mIGFuIGluZGl2aWR1YWwgb3BlcmF0b3IgYXMgd2VsbCwgCmluIGFkZGl0aW9uIHRvIHByb3ZpZGluZyBhIHNwZWNpYWxpemF0aW9uIGZvciBhIGdyb3VwIG9mIG9wZXJhdG9ycy4gClNheSwgd2UgYWRkIGEgbmV3IGFyaXRobWV0aWMgb3BlcmF0b3IgZm9yIGFyZ3VtZW50IHR5cGVzIDxsaXRlcmFsPlg8L2xpdGVyYWw+IAphbmQgPGxpdGVyYWw+WTwvbGl0ZXJhbD46Cgo8cHJvZ3JhbWxpc3Rpbmc+CjwhW0NEQVRBW1ggb3BlcmF0b3IqKGNvbnN0IFgmLCBjb25zdCBZJik7XV0+CjwvcHJvZ3JhbWxpc3Rpbmc+CgpPdXIgZmlyc3QgcnVsZSBmb3IgYWxsIGFyaXRobWV0aWMgb3BlcmF0b3JzIHNwZWNpZmllcyB0aGF0IHRoZSByZXR1cm4gCnR5cGUgb2YgdGhpcyBvcGVyYXRvciBpcyA8bGl0ZXJhbD5aPC9saXRlcmFsPiwgCndoaWNoIG9idmlvdXNseSBpcyBub3QgdGhlIGNhc2UuCkhlbmNlLCB3ZSBwcm92aWRlIGEgbmV3IHJ1bGUgZm9yIHRoZSBtdWx0aXBsaWNhdGlvbiBvcGVyYXRvcjoKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbdGVtcGxhdGU8PiAKc3RydWN0IHBsYWluX3JldHVybl90eXBlXzI8YXJpdGhtZXRpY19hY3Rpb248bXVsdGlwbHlfYWN0aW9uPiwgWCwgWT4gewogIHR5cGVkZWYgWCB0eXBlOwp9O11dPgo8L3Byb2dyYW1saXN0aW5nPgo8L3BhcmE+Cgo8cGFyYT4KVGhlIHNwZWNpYWxpemF0aW9ucyBjYW4gZGVmaW5lIGFyYml0cmFyeSBtYXBwaW5ncyBmcm9tIHRoZSBhcmd1bWVudCB0eXBlcyAKdG8gdGhlIHJldHVybiB0eXBlLiAKClN1cHBvc2Ugd2UgaGF2ZSBzb21lIG1hdGhlbWF0aWNhbCB2ZWN0b3IgdHlwZSwgdGVtcGxhdGVkIG9uIHRoZSBlbGVtZW50IHR5cGU6Cgo8cHJvZ3JhbWxpc3Rpbmc+CjwhW0NEQVRBW3RlbXBsYXRlIDxjbGFzcyBUPiBjbGFzcyBteV92ZWN0b3I7XV0+CjwvcHJvZ3JhbWxpc3Rpbmc+CgpTdXBwb3NlIHRoZSBhZGRpdGlvbiBvcGVyYXRvciBpcyBkZWZpbmVkIGJldHdlZW4gYW55IHR3byAKPGxpdGVyYWw+bXlfdmVjdG9yPC9saXRlcmFsPiBpbnN0YW50aWF0aW9ucywgCmFzIGxvbmcgYXMgdGhlIGFkZGl0aW9uIG9wZXJhdG9yIGlzIGRlZmluZWQgYmV0d2VlbiB0aGVpciBlbGVtZW50IHR5cGVzLiAKCkZ1cnRoZXJtb3JlLCB0aGUgZWxlbWVudCB0eXBlIG9mIHRoZSByZXN1bHRpbmcgPGxpdGVyYWw+bXlfdmVjdG9yPC9saXRlcmFsPiAKaXMgdGhlIHNhbWUgYXMgdGhlIHJlc3VsdCB0eXBlIG9mIHRoZSBhZGRpdGlvbiBiZXR3ZWVuIHRoZSBlbGVtZW50IHR5cGVzLgoKRS5nLiwgYWRkaW5nIDxsaXRlcmFsPjwhW0NEQVRBW215X3ZlY3RvcjxpbnQ+XV0+PC9saXRlcmFsPiBhbmQgCjxsaXRlcmFsPjwhW0NEQVRBW215X3ZlY3Rvcjxkb3VibGU+XV0+PC9saXRlcmFsPiByZXN1bHRzIGluIAo8bGl0ZXJhbD48IVtDREFUQVtteV92ZWN0b3I8ZG91YmxlPl1dPjwvbGl0ZXJhbD4uCgpUaGUgQkxMIGhhcyB0cmFpdHMgY2xhc3NlcyB0byBwZXJmb3JtIHRoZSBpbXBsaWNpdCBidWlsdC1pbiBhbmQgc3RhbmRhcmQgCnR5cGUgY29udmVyc2lvbnMgYmV0d2VlbiBpbnRlZ3JhbCwgZmxvYXRpbmcgcG9pbnQsIGFuZCBjb21wbGV4IGNsYXNzZXMuCgpVc2luZyBCTEwgdG9vbHMsIHRoZSBhZGRpdGlvbiBvcGVyYXRvciBkZXNjcmliZWQgYWJvdmUgY2FuIGJlIGRlZmluZWQgYXM6Cgo8cHJvZ3JhbWxpc3Rpbmc+CjwhW0NEQVRBW3RlbXBsYXRlPGNsYXNzIEEsIGNsYXNzIEI+IApteV92ZWN0b3I8dHlwZW5hbWUgcmV0dXJuX3R5cGVfMjxhcml0aG1ldGljX2FjdGlvbjxwbHVzX2FjdGlvbj4sIEEsIEI+Ojp0eXBlPgpvcGVyYXRvcisoY29uc3QgbXlfdmVjdG9yPEE+JiBhLCBjb25zdCBteV92ZWN0b3I8Qj4mIGIpCnsKICB0eXBlZGVmIHR5cGVuYW1lIAogICAgcmV0dXJuX3R5cGVfMjxhcml0aG1ldGljX2FjdGlvbjxwbHVzX2FjdGlvbj4sIEEsIEI+Ojp0eXBlIHJlc190eXBlOwogIHJldHVybiBteV92ZWN0b3I8cmVzX3R5cGU+KCk7Cn1dXT4KPC9wcm9ncmFtbGlzdGluZz4KPC9wYXJhPgoKPHBhcmE+ClRvIGFsbG93IEJMTCB0byBkZWR1Y2UgdGhlIHR5cGUgb2YgPGxpdGVyYWw+bXlfdmVjdG9yPC9saXRlcmFsPiAKYWRkaXRpb25zIGNvcnJlY3RseSwgd2UgY2FuIGRlZmluZToKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbdGVtcGxhdGU8Y2xhc3MgQSwgY2xhc3MgQj4gCmNsYXNzIHBsYWluX3JldHVybl90eXBlXzI8YXJpdGhtZXRpY19hY3Rpb248cGx1c19hY3Rpb24+LCAKICAgICAgICAgICAgICAgICAgICAgICAgICAgbXlfdmVjdG9yPEE+LCBteV92ZWN0b3I8Qj4gPiB7CiAgdHlwZWRlZiB0eXBlbmFtZSAKICAgIHJldHVybl90eXBlXzI8YXJpdGhtZXRpY19hY3Rpb248cGx1c19hY3Rpb24+LCBBLCBCPjo6dHlwZSByZXNfdHlwZTsKcHVibGljOgogIHR5cGVkZWYgbXlfdmVjdG9yPHJlc190eXBlPiB0eXBlOwp9O11dPgo8L3Byb2dyYW1saXN0aW5nPgpOb3RlLCB0aGF0IHdlIGFyZSByZXVzaW5nIHRoZSBleGlzdGluZyBzcGVjaWFsaXphdGlvbnMgZm9yIHRoZSAKQkxMIDxsaXRlcmFsPnJldHVybl90eXBlXzI8L2xpdGVyYWw+IHRlbXBsYXRlLCAKd2hpY2ggcmVxdWlyZSB0aGF0IHRoZSBhcmd1bWVudCB0eXBlcyBhcmUgcmVmZXJlbmNlcy4gCjwvcGFyYT4KCjwhLS0gVE9ETzogaXMgYW4gZXhhbXBsZSBvZiBzcGVjaWZ5aW5nIHRoZSBvdGhlciBsZXZlbCBuZWVkZWQgYXQgYWxsIC0tPgo8IS0tIFRPRE86IGNvbW1hIG9wZXJhdG9yIGlzIGEgc3BlY2lhbCBjYXNlIGZvciB0aGF0IC0tPgoKPHRhYmxlIGlkID0gInRhYmxlOmFjdGlvbnMiPgo8dGl0bGU+QWN0aW9uIHR5cGVzPC90aXRsZT4KPHRncm91cCBjb2xzPSIyIj4KPHRib2R5PgoKPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbK11dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVthcml0aG1ldGljX2FjdGlvbjxwbHVzX2FjdGlvbj5dXT48L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbLV1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVthcml0aG1ldGljX2FjdGlvbjxtaW51c19hY3Rpb24+XV0+PC9saXRlcmFsPjwvZW50cnk+PC9yb3c+Cjxyb3c+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBWypdXT48L2xpdGVyYWw+PC9lbnRyeT48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbYXJpdGhtZXRpY19hY3Rpb248bXVsdGlwbHlfYWN0aW9uPl1dPjwvbGl0ZXJhbD48L2VudHJ5Pjwvcm93Pgo8cm93PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVsvXV0+PC9saXRlcmFsPjwvZW50cnk+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBW2FyaXRobWV0aWNfYWN0aW9uPGRpdmlkZV9hY3Rpb24+XV0+PC9saXRlcmFsPjwvZW50cnk+PC9yb3c+Cjxyb3c+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBWyVdXT48L2xpdGVyYWw+PC9lbnRyeT48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbYXJpdGhtZXRpY19hY3Rpb248cmVtYWluZGVyX2FjdGlvbj5dXT48L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KCgoKPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbK11dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVt1bmFyeV9hcml0aG1ldGljX2FjdGlvbjxwbHVzX2FjdGlvbj5dXT48L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbLV1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVt1bmFyeV9hcml0aG1ldGljX2FjdGlvbjxtaW51c19hY3Rpb24+XV0+PC9saXRlcmFsPjwvZW50cnk+PC9yb3c+CgoKCjxyb3c+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBWyZdXT48L2xpdGVyYWw+PC9lbnRyeT48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbYml0d2lzZV9hY3Rpb248YW5kX2FjdGlvbj5dXT48L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbfF1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtiaXR3aXNlX2FjdGlvbjxvcl9hY3Rpb24+XV0+PC9saXRlcmFsPjwvZW50cnk+PC9yb3c+Cjxyb3c+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBW35dXT48L2xpdGVyYWw+PC9lbnRyeT48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbYml0d2lzZV9hY3Rpb248bm90X2FjdGlvbj5dXT48L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbXl1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtiaXR3aXNlX2FjdGlvbjx4b3JfYWN0aW9uPl1dPjwvbGl0ZXJhbD48L2VudHJ5Pjwvcm93Pgo8cm93PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVs8PF1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtiaXR3aXNlX2FjdGlvbjxsZWZ0c2hpZnRfYWN0aW9uX25vX3N0cmVhbT5dXT48L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbPj5dXT48L2xpdGVyYWw+PC9lbnRyeT48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbYml0d2lzZV9hY3Rpb248cmlnaHRzaGlmdF9hY3Rpb25fbm9fc3RyZWFtPl1dPjwvbGl0ZXJhbD48L2VudHJ5Pjwvcm93PgoKCgo8cm93PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVsmJl1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtsb2dpY2FsX2FjdGlvbjxhbmRfYWN0aW9uPl1dPjwvbGl0ZXJhbD48L2VudHJ5Pjwvcm93Pgo8cm93PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVt8fF1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtsb2dpY2FsX2FjdGlvbjxvcl9hY3Rpb24+XV0+PC9saXRlcmFsPjwvZW50cnk+PC9yb3c+Cjxyb3c+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBWyFdXT48L2xpdGVyYWw+PC9lbnRyeT48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbbG9naWNhbF9hY3Rpb248bm90X2FjdGlvbj5dXT48L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KCgoKPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbPF1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtyZWxhdGlvbmFsX2FjdGlvbjxsZXNzX2FjdGlvbj5dXT48L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbPl1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtyZWxhdGlvbmFsX2FjdGlvbjxncmVhdGVyX2FjdGlvbj5dXT48L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbPD1dXT48L2xpdGVyYWw+PC9lbnRyeT48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbcmVsYXRpb25hbF9hY3Rpb248bGVzc29yZXF1YWxfYWN0aW9uPl1dPjwvbGl0ZXJhbD48L2VudHJ5Pjwvcm93Pgo8cm93PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVs+PV1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtyZWxhdGlvbmFsX2FjdGlvbjxncmVhdGVyb3JlcXVhbF9hY3Rpb24+XV0+PC9saXRlcmFsPjwvZW50cnk+PC9yb3c+Cjxyb3c+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBWz09XV0+PC9saXRlcmFsPjwvZW50cnk+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBW3JlbGF0aW9uYWxfYWN0aW9uPGVxdWFsX2FjdGlvbj5dXT48L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbIT1dXT48L2xpdGVyYWw+PC9lbnRyeT48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbcmVsYXRpb25hbF9hY3Rpb248bm90ZXF1YWxfYWN0aW9uPl1dPjwvbGl0ZXJhbD48L2VudHJ5Pjwvcm93PgoKCgo8cm93PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVsrPV1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVthcml0aG1ldGljX2Fzc2lnbm1lbnRfYWN0aW9uPHBsdXNfYWN0aW9uPl1dPjwvbGl0ZXJhbD48L2VudHJ5Pjwvcm93Pgo8cm93PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVstPV1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVthcml0aG1ldGljX2Fzc2lnbm1lbnRfYWN0aW9uPG1pbnVzX2FjdGlvbj5dXT48L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbKj1dXT48L2xpdGVyYWw+PC9lbnRyeT48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbYXJpdGhtZXRpY19hc3NpZ25tZW50X2FjdGlvbjxtdWx0aXBseV9hY3Rpb24+XV0+PC9saXRlcmFsPjwvZW50cnk+PC9yb3c+Cjxyb3c+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBWy89XV0+PC9saXRlcmFsPjwvZW50cnk+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBW2FyaXRobWV0aWNfYXNzaWdubWVudF9hY3Rpb248ZGl2aWRlX2FjdGlvbj5dXT48L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbJT1dXT48L2xpdGVyYWw+PC9lbnRyeT48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbYXJpdGhtZXRpY19hc3NpZ25tZW50X2FjdGlvbjxyZW1haW5kZXJfYWN0aW9uPl1dPjwvbGl0ZXJhbD48L2VudHJ5Pjwvcm93PgoKCgo8cm93PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVsmPV1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtiaXR3aXNlX2Fzc2lnbm1lbnRfYWN0aW9uPGFuZF9hY3Rpb24+XV0+PC9saXRlcmFsPjwvZW50cnk+PC9yb3c+Cjxyb3c+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBWz18XV0+PC9saXRlcmFsPjwvZW50cnk+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBW2JpdHdpc2VfYXNzaWdubWVudF9hY3Rpb248b3JfYWN0aW9uPl1dPjwvbGl0ZXJhbD48L2VudHJ5Pjwvcm93Pgo8cm93PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtePV1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtiaXR3aXNlX2Fzc2lnbm1lbnRfYWN0aW9uPHhvcl9hY3Rpb24+XV0+PC9saXRlcmFsPjwvZW50cnk+PC9yb3c+Cjxyb3c+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBWzw8PV1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtiaXR3aXNlX2Fzc2lnbm1lbnRfYWN0aW9uPGxlZnRzaGlmdF9hY3Rpb24+XV0+PC9saXRlcmFsPjwvZW50cnk+PC9yb3c+Cjxyb3c+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBWz4+PV1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtiaXR3aXNlX2Fzc2lnbm1lbnRfYWN0aW9uPHJpZ2h0c2hpZnRfYWN0aW9uPl1dPjwvbGl0ZXJhbD48L2VudHJ5Pjwvcm93PgoKCgo8cm93PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVsrK11dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtwcmVfaW5jcmVtZW50X2RlY3JlbWVudF9hY3Rpb248aW5jcmVtZW50X2FjdGlvbj5dXT48L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbLS1dXT48L2xpdGVyYWw+PC9lbnRyeT48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbcHJlX2luY3JlbWVudF9kZWNyZW1lbnRfYWN0aW9uPGRlY3JlbWVudF9hY3Rpb24+XV0+PC9saXRlcmFsPjwvZW50cnk+PC9yb3c+Cjxyb3c+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBWysrXV0+PC9saXRlcmFsPjwvZW50cnk+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBW3Bvc3RfaW5jcmVtZW50X2RlY3JlbWVudF9hY3Rpb248aW5jcmVtZW50X2FjdGlvbj5dXT48L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbLS1dXT48L2xpdGVyYWw+PC9lbnRyeT48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbcG9zdF9pbmNyZW1lbnRfZGVjcmVtZW50X2FjdGlvbjxkZWNyZW1lbnRfYWN0aW9uPl1dPjwvbGl0ZXJhbD48L2VudHJ5Pjwvcm93PgoKCgo8cm93PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVsmXV0+PC9saXRlcmFsPjwvZW50cnk+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBW290aGVyX2FjdGlvbjxhZGRyZXNzX29mX2FjdGlvbj5dXT48L2xpdGVyYWw+PC9lbnRyeT48L3Jvdz4KPHJvdz48ZW50cnk+PGxpdGVyYWw+PCFbQ0RBVEFbKl1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtvdGhlcl9hY3Rpb248Y29udGVudHNfb2ZfYWN0aW9uPl1dPjwvbGl0ZXJhbD48L2VudHJ5Pjwvcm93Pgo8cm93PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVssXV0+PC9saXRlcmFsPjwvZW50cnk+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBW290aGVyX2FjdGlvbjxjb21tYV9hY3Rpb24+XV0+PC9saXRlcmFsPjwvZW50cnk+PC9yb3c+Cjxyb3c+PGVudHJ5PjxsaXRlcmFsPjwhW0NEQVRBWy0+Kl1dPjwvbGl0ZXJhbD48L2VudHJ5PjxlbnRyeT48bGl0ZXJhbD48IVtDREFUQVtvdGhlcl9hY3Rpb248bWVtYmVyX3BvaW50ZXJfYWN0aW9uPl1dPjwvbGl0ZXJhbD48L2VudHJ5Pjwvcm93PgoKPC90Ym9keT4KPC90Z3JvdXA+CjwvdGFibGU+Cgo8L3NlY3Rpb24+CgoKPHNlY3Rpb24+Cjx0aXRsZT5QcmFjdGljYWwgY29uc2lkZXJhdGlvbnM8L3RpdGxlPgoKCjxzZWN0aW9uPgo8dGl0bGU+UGVyZm9ybWFuY2U8L3RpdGxlPgoKPHBhcmE+SW4gdGhlb3J5LCBhbGwgb3ZlcmhlYWQgb2YgdXNpbmcgU1RMIGFsZ29yaXRobXMgYW5kIGxhbWJkYSBmdW5jdG9ycyAKY29tcGFyZWQgdG8gaGFuZCB3cml0dGVuIGxvb3BzIGNhbiBiZSBvcHRpbWl6ZWQgYXdheSwganVzdCBhcyB0aGUgb3ZlcmhlYWQgCmZyb20gc3RhbmRhcmQgU1RMIGZ1bmN0aW9uIG9iamVjdHMgYW5kIGJpbmRlcnMgY2FuLgoKRGVwZW5kaW5nIG9uIHRoZSBjb21waWxlciwgdGhpcyBjYW4gYWxzbyBiZSB0cnVlIGluIHByYWN0aWNlLgpXZSByYW4gdHdvIHRlc3RzIHdpdGggdGhlIEdDQyAzLjAuNCBjb21waWxlciBvbiAxLjUgR0h6IEludGVsIFBlbnRpdW0gNC4KVGhlIG9wdGltaXphdGlvbiBmbGFnIC0wMyB3YXMgdXNlZC4KPC9wYXJhPgoKPHBhcmE+CkluIHRoZSBmaXJzdCB0ZXN0IHdlIGNvbXBhcmVkIGxhbWJkYSBmdW5jdG9ycyBhZ2FpbnN0IGV4cGxpY2l0bHkgd3JpdHRlbiAKZnVuY3Rpb24gb2JqZWN0cy4gCldlIHVzZWQgYm90aCBvZiB0aGVzZSBzdHlsZXMgdG8gZGVmaW5lIHVuYXJ5IGZ1bmN0aW9ucyB3aGljaCBtdWx0aXBseSB0aGUKYXJndW1lbnQgcmVwZWF0ZWRseSBieSBpdHNlbGYuIApXZSBzdGFydGVkIHdpdGggdGhlIGlkZW50aXR5IGZ1bmN0aW9uLCBnb2luZyB1cCB0byAKeDxzdXBlcnNjcmlwdD41PC9zdXBlcnNjcmlwdD4uClRoZSBleHByZXNzaW9ucyB3ZXJlIGNhbGxlZCBpbnNpZGUgYSA8bGl0ZXJhbD5zdGQ6OnRyYW5zZm9ybTwvbGl0ZXJhbD4gbG9vcCwgCnJlYWRpbmcgdGhlIGFyZ3VtZW50IGZyb20gb25lIDxsaXRlcmFsPjwhW0NEQVRBW3N0ZDo6dmVjdG9yPGludD5dXT48L2xpdGVyYWw+IAphbmQgcGxhY2luZyB0aGUgcmVzdWx0IGludG8gYW5vdGhlci4KVGhlIGxlbmd0aCBvZiB0aGUgdmVjdG9ycyB3YXMgMTAwIGVsZW1lbnRzLgpUaGUgcnVubmluZyB0aW1lcyBhcmUgbGlzdGVkIGluIAo8eHJlZiBsaW5rZW5kPSJ0YWJsZTppbmNyZWFzaW5nX2FyaXRobWV0aWNfdGVzdCIvPi4KCldlIGNhbiBvYnNlcnZlIHRoYXQgdGhlcmUgaXMgbm8gc2lnbmlmaWNhbnQgZGlmZmVyZW5jZSBiZXR3ZWVuIHRoZQp0d28gYXBwcm9hY2hlcy4KPC9wYXJhPgoKPHBhcmE+CkluIHRoZSBzZWNvbmQgdGVzdCB3ZSBhZ2FpbiB1c2VkIDxsaXRlcmFsPnN0ZDo6dHJhbnNmb3JtPC9saXRlcmFsPiB0byAKcGVyZm9ybSBhbiBvcGVyYXRpb24gdG8gZWFjaCBlbGVtZW50IGluIGEgMTAwLWVsZW1lbnQgbG9uZyB2ZWN0b3IuClRoaXMgdGltZSB0aGUgZWxlbWVudCB0eXBlIG9mIHRoZSB2ZWN0b3JzIHdhcyA8bGl0ZXJhbD5kb3VibGU8L2xpdGVyYWw+CmFuZCB3ZSBzdGFydGVkIHdpdGggdmVyeSBzaW1wbGUgYXJpdGhtZXRpYyBleHByZXNzaW9ucyBhbmQgbW92ZWQgdG8gCm1vcmUgY29tcGxleCBvbmVzLgpUaGUgcnVubmluZyB0aW1lcyBhcmUgbGlzdGVkIGluIDx4cmVmIGxpbmtlbmQ9InRhYmxlOmxsX3ZzX3N0bF90ZXN0Ii8+LgoKSGVyZSwgd2UgYWxzbyBpbmNsdWRlZCBjbGFzc2ljIFNUTCBzdHlsZSB1bm5hbWVkIGZ1bmN0aW9ucyBpbnRvIHRlc3RzLgpXZSBkbyBub3Qgc2hvdyB0aGVzZSBleHByZXNzaW9ucywgYXMgdGhleSBnZXQgcmF0aGVyIGNvbXBsZXguIApGb3IgZXhhbXBsZSwgdGhlCmxhc3QgZXhwcmVzc2lvbiBpbiA8eHJlZiBsaW5rZW5kPSJ0YWJsZTpsbF92c19zdGxfdGVzdCIvPiB3cml0dGVuIHdpdGgKY2xhc3NpYyBTVEwgdG9vbHMgY29udGFpbnMgNyBjYWxscyB0byA8bGl0ZXJhbD5jb21wb3NlMjwvbGl0ZXJhbD4sIAo4IGNhbGxzIHRvIDxsaXRlcmFsPmJpbmQxc3Q8L2xpdGVyYWw+CmFuZCBhbHRvZ2V0aGVyIDE0IGNvbnN0cnVjdG9yIGludm9jYXRpb25zIGZvciBjcmVhdGluZyAKPGxpdGVyYWw+bXVsdGlwbGllczwvbGl0ZXJhbD4sIDxsaXRlcmFsPm1pbnVzPC9saXRlcmFsPiAKYW5kIDxsaXRlcmFsPnBsdXM8L2xpdGVyYWw+IG9iamVjdHMuCgpJbiB0aGlzIHRlc3QgdGhlIEJMTCBleHByZXNzaW9ucyBhcmUgYSBsaXR0bGUgc2xvd2VyIChyb3VnaGx5IDEwJSBvbiBhdmVyYWdlLApsZXNzIHRoYW4gMTQlIGluIGFsbCBjYXNlcykKdGhhbiB0aGUgY29ycmVzcG9uZGluZyBoYW5kLXdyaXR0ZW4gZnVuY3Rpb24gb2JqZWN0cy4KVGhlIHBlcmZvcm1hbmNlIGhpdCBpcyBhIGJpdCBncmVhdGVyIHdpdGggY2xhc3NpYyBTVEwgZXhwcmVzc2lvbnMsCnVwIHRvIDI3JSBmb3IgdGhlIHNpbXBsZXN0IGV4cHJlc3Npb3MuCjwvcGFyYT4KCjxwYXJhPgpUaGUgdGVzdHMgc3VnZ2VzdCB0aGF0IHRoZSBCTEwgZG9lcyBub3QgaW50cm9kdWNlIGEgbG9zcyBvZiBwZXJmb3JtYW5jZSAKY29tcGFyZWQgdG8gU1RMIGZ1bmN0aW9uIG9iamVjdHMuICAKV2l0aCBhIHJlYXNvbmFibGUgb3B0aW1pemluZyBjb21waWxlciwgb25lIHNob3VsZCBleHBlY3QgdGhlIHBlcmZvcm1hbmNlIGNoYXJhY3RlcmlzdGljcyBiZSBjb21wYXJhYmxlIHRvIHVzaW5nIGNsYXNzaWMgU1RMLgpNb3Jlb3Zlciwgd2l0aCBzaW1wbGUgZXhwcmVzc2lvbnMgdGhlIHBlcmZvcm1hbmNlIGNhbiBiZSBleHBlY3RlZCB0byBiZSBjbG9zZQp0byB0aGF0IG9mIGV4cGxpY2l0bHkgd3JpdHRlbiBmdW5jdGlvbiBvYmplY3RzLgoKPCEtLSBXZSByZXBlYXRlZCBib3RoIHRlc3RzIHdpdGggdGhlIEtBSSBDKysgNC4wZiBjb21waWxlciAodXNpbmcgK0syIC1PMyBmbGFncyksIApnZW5lcmFsbHkgY29uc2lkZXJlZCBhIGdvb2Qgb3B0aW1pemluZyBjb21waWxlci4KV2UgZG8gbm90IGxpc3QgdGhlIHJlc3VsdHMgaGVyZSwgc2luY2UgdGhlIHJ1bm5pbmcgdGltZXMgZm9yIHRoZSB0d28gYWx0ZXJuYXRpdmVzIGluIHRoZSBmaXJzdCB0ZXN0IHdlcmUgZXNzZW50aWFsbHkgdGhlIHNhbWUsIGp1c3QgYXMgdGhlIHJ1bm5pbmcgdGltZXMKZm9yIHRoZSB0aHJlZSBkaWZmZXJlbnQgYWx0ZXJuYXRpdmVzIGluIHRoZSBzZWNvbmQgdGVzdC4KVGhlc2UgdGVzdHMgc3VnZ2VzdCB0aGVyZSB0byBiZSBubyBwZXJmb3JtYW5jZSBwZW5hbHR5IGF0IGFsbAp3aXRoIGEgZ29vZCBvcHRpbWl6aW5nIGNvbXBpbGVyLgotLT4KCk5vdGUgaG93ZXZlciwgdGhhdCBldmFsdWF0aW5nIGEgbGFtYmRhIGZ1bmN0b3IgY29uc2lzdCBvZiBhIHNlcXVlbmNlIG9mIGNhbGxzIHRvIHNtYWxsIGZ1bmN0aW9ucyB0aGF0IGFyZSBkZWNsYXJlZCBpbmxpbmUuIApJZiB0aGUgY29tcGlsZXIgZmFpbHMgdG8gYWN0dWFsbHkgZXhwYW5kIHRoZXNlIGZ1bmN0aW9ucyBpbmxpbmUsIAp0aGUgcGVyZm9ybWFuY2UgY2FuIHN1ZmZlci4gClRoZSBydW5uaW5nIHRpbWUgY2FuIG1vcmUgdGhhbiBkb3VibGUgaWYgdGhpcyBoYXBwZW5zLgpBbHRob3VnaCB0aGUgYWJvdmUgdGVzdHMgZG8gbm90IGluY2x1ZGUgc3VjaCBhbiBleHByZXNzaW9uLCB3ZSBoYXZlIGV4cGVyaWVuY2VkCnRoaXMgZm9yIHNvbWUgc2VlbWluZ2x5IHNpbXBsZSBleHByZXNzaW9ucy4KCgo8dGFibGUgaWQgPSAidGFibGU6aW5jcmVhc2luZ19hcml0aG1ldGljX3Rlc3QiPgo8dGl0bGU+VGVzdCAxPC90aXRsZT4KPGNhcHRpb24+Q1BVIHRpbWUgb2YgZXhwcmVzc2lvbnMgd2l0aCBpbnRlZ2VyIG11bHRpcGxpY2F0aW9uIHdyaXR0ZW4gYXMgYSBsYW1iZGEgZXhwcmVzc2lvbiBhbmQgYXMgYSB0cmFkaXRpb25hbCBoYW5kLWNvZGVkIGZ1bmN0aW9uIG9iamVjdCBjbGFzcy4gClRoZSBydW5uaW5nIHRpbWVzIGFyZSBleHByZXNzZWQgaW4gYXJiaXRyYXJ5IHVuaXRzLjwvY2FwdGlvbj4KPHRncm91cCBjb2xzPSIzIj4KPHRoZWFkPgo8cm93Pgo8ZW50cnk+ZXhwcmVzc2lvbjwvZW50cnk+PGVudHJ5PmxhbWJkYSBleHByZXNzaW9uPC9lbnRyeT48ZW50cnk+aGFuZC1jb2RlZCBmdW5jdGlvbiBvYmplY3Q8L2VudHJ5Pjwvcm93Pgo8L3RoZWFkPgoKPHRib2R5PgoKPHJvdz4KPGVudHJ5Png8L2VudHJ5PjxlbnRyeT4yNDA8L2VudHJ5PjxlbnRyeT4yMzA8L2VudHJ5Pgo8L3Jvdz4KCjxyb3c+CjxlbnRyeT54Kng8L2VudHJ5PjxlbnRyeT4zNDA8L2VudHJ5PjxlbnRyeT4zNTA8L2VudHJ5Pgo8L3Jvdz4KCjxyb3c+CjxlbnRyeT54KngqeDwvZW50cnk+PGVudHJ5Pjc3MDwvZW50cnk+PGVudHJ5Pjc2MDwvZW50cnk+Cjwvcm93PgoKPHJvdz4KPGVudHJ5PngqeCp4Kng8L2VudHJ5PjxlbnRyeT4xMTgwPC9lbnRyeT48ZW50cnk+MTIxMDwvZW50cnk+Cjwvcm93PgoKPHJvdz4KPGVudHJ5PngqeCp4KngqeDwvZW50cnk+PGVudHJ5PjE5NTA8L2VudHJ5PjxlbnRyeT4xOTEwPC9lbnRyeT4KPC9yb3c+Cgo8L3Rib2R5Pgo8L3Rncm91cD4KPC90YWJsZT4KPC9wYXJhPgoKPCEtLQoxNjoxOTo0OSBiZW5jaCBbNjAxXSAuL2FyaXRoLm91dCAxMDAgMTAwMDAwMAoKTnVtYmVyIG9mIGVsZW1lbnRzID0gMTAwCkwxIDogMjQwCkwyIDogMzQwCkwzIDogNzcwCkw0IDogMTE4MApMNSA6IDE5NTAKClAyIDogMTcwMApQMyA6IDIxMzAKUDQgOiAyNTMwClA1IDogMzAwMAoKRjEgOiAyMzAKRjIgOiAzNTAKRjMgOiA3NjAKRjQgOiAxMjEwCkY1IDogMTkxMAoKCk51bWJlciBvZiBlbGVtZW50cyAgICA9IDEwMApOdW1iZXIgb2Ygb3V0ZXJfaXRlcnMgPSAxMDAwMDAwCkwxIDogMzMwCkwyIDogMzUwCkwzIDogNDcwCkw0IDogNjIwCkw1IDogMTY2MApMUCA6IDEyMzAKQzEgOiAzNzAKQzIgOiAzNzAKQzMgOiA1MDAKQzQgOiA2NzAKQzUgOiAxNjYwCkNQIDogMTc3MApGMSA6IDI5MApGMiA6IDMxMApGMyA6IDQyMApGNCA6IDYwMApGNSA6IDE0NjAKRlAgOiAxMDQwCgotLT4KCgo8cGFyYT4KPHRhYmxlIGlkID0gInRhYmxlOmxsX3ZzX3N0bF90ZXN0Ij4KPHRpdGxlPlRlc3QgMjwvdGl0bGU+CjxjYXB0aW9uPkNQVSB0aW1lIG9mIGFyaXRobWV0aWMgZXhwcmVzc2lvbnMgd3JpdHRlbiBhcyBsYW1iZGEgCmV4cHJlc3Npb25zLCBhcyBjbGFzc2ljIFNUTCB1bm5hbWVkIGZ1bmN0aW9ucyAodXNpbmcgPGxpdGVyYWw+Y29tcG9zZTI8L2xpdGVyYWw+LCA8bGl0ZXJhbD5iaW5kMXN0PC9saXRlcmFsPiBldGMuKSBhbmQgYXMgdHJhZGl0aW9uYWwgaGFuZC1jb2RlZCBmdW5jdGlvbiBvYmplY3QgY2xhc3Nlcy4gClVzaW5nIEJMTCB0ZXJtaW5vbG9neSwgCjxsaXRlcmFsPmE8L2xpdGVyYWw+IGFuZCA8bGl0ZXJhbD5iPC9saXRlcmFsPiBhcmUgYm91bmQgYXJndW1lbnRzIGluIHRoZSBleHByZXNzaW9ucywgYW5kIDxsaXRlcmFsPng8L2xpdGVyYWw+IGlzIG9wZW4uIApBbGwgdmFyaWFibGVzIHdlcmUgb2YgdHlwZXMgPGxpdGVyYWw+ZG91YmxlPC9saXRlcmFsPi4KVGhlIHJ1bm5pbmcgdGltZXMgYXJlIGV4cHJlc3NlZCBpbiBhcmJpdHJhcnkgdW5pdHMuPC9jYXB0aW9uPgo8dGdyb3VwIGNvbHM9IjQiPgo8dGhlYWQ+Cjxyb3c+CjxlbnRyeT5leHByZXNzaW9uPC9lbnRyeT48ZW50cnk+bGFtYmRhIGV4cHJlc3Npb248L2VudHJ5PjxlbnRyeT5jbGFzc2ljIFNUTCBleHByZXNzaW9uPC9lbnRyeT48ZW50cnk+aGFuZC1jb2RlZCBmdW5jdGlvbiBvYmplY3Q8L2VudHJ5Pjwvcm93Pgo8L3RoZWFkPgoKPHRib2R5PgoKPHJvdz4KPGVudHJ5PmF4PC9lbnRyeT48ZW50cnk+MzMwPC9lbnRyeT48ZW50cnk+MzcwPC9lbnRyeT48ZW50cnk+MjkwPC9lbnRyeT4KPC9yb3c+Cgo8cm93Pgo8ZW50cnk+LWF4PC9lbnRyeT48ZW50cnk+MzUwPC9lbnRyeT48ZW50cnk+MzcwPC9lbnRyeT48ZW50cnk+MzEwPC9lbnRyeT4KPC9yb3c+Cgo8cm93Pgo8ZW50cnk+YXgtKGEreCk8L2VudHJ5PjxlbnRyeT40NzA8L2VudHJ5PjxlbnRyeT41MDA8L2VudHJ5PjxlbnRyeT40MjA8L2VudHJ5Pgo8L3Jvdz4KCjxyb3c+CjxlbnRyeT4oYXgtKGEreCkpKGEreCk8L2VudHJ5PjxlbnRyeT42MjA8L2VudHJ5PjxlbnRyeT42NzA8L2VudHJ5PjxlbnRyeT42MDA8L2VudHJ5Pgo8L3Jvdz4KCjxyb3c+CjxlbnRyeT4oKGF4KSAtIChhK3gpKShieCAtIChiK3gpKShheCAtIChiK3gpKShieCAtIChhK3gpKTwvZW50cnk+PGVudHJ5PjE2NjA8L2VudHJ5PjxlbnRyeT4xNjYwPC9lbnRyeT48ZW50cnk+MTQ2MDwvZW50cnk+Cjwvcm93PgoKPC90Ym9keT4KPC90Z3JvdXA+Cgo8L3RhYmxlPgo8L3BhcmE+CgoKPHBhcmE+U29tZSBhZGRpdGlvbmFsIHBlcmZvcm1hbmNlIHRlc3Rpbmcgd2l0aCBhbiBlYXJsaWVyIHZlcnNpb24gb2YgdGhlCmxpYnJhcnkgaXMgZGVzY3JpYmVkCjx4cmVmIGxpbmtlbmQ9ImNpdDpqYXJ2aTowMCIvPi4KPC9wYXJhPgoKPC9zZWN0aW9uPgogICAgPHNlY3Rpb24+CiAgICAgIDx0aXRsZT5BYm91dCBjb21waWxpbmc8L3RpdGxlPgoKICAgICAgPHBhcmE+VGhlIEJMTCB1c2VzIHRlbXBsYXRlcyByYXRoZXIgaGVhdmlseSwgcGVyZm9ybWluZyBudW1lcm91cyByZWN1cnNpdmUgaW5zdGFudGlhdGlvbnMgb2YgdGhlIHNhbWUgdGVtcGxhdGVzLiAKVGhpcyBoYXMgKGF0IGxlYXN0KSB0aHJlZSBpbXBsaWNhdGlvbnM6CjxpdGVtaXplZGxpc3Q+Cgo8bGlzdGl0ZW0+CjxwYXJhPgpXaGlsZSBpdCBpcyBwb3NzaWJsZSB0byB3cml0ZSBpbmNyZWRpYmx5IGNvbXBsZXggbGFtYmRhIGV4cHJlc3Npb25zLCBpdCBwcm9iYWJseSBpc24ndCBhIGdvb2QgaWRlYS4gCkNvbXBpbGluZyBzdWNoIGV4cHJlc3Npb25zIG1heSBlbmQgdXAgcmVxdWlyaW5nIGEgbG90IG9mIG1lbW9yeSAKYXQgY29tcGlsZSB0aW1lLCBhbmQgYmVpbmcgc2xvdyB0byBjb21waWxlLgo8L3BhcmE+CjwvbGlzdGl0ZW0+CgoKPGxpc3RpdGVtPgo8cGFyYT4KVGhlIHR5cGVzIG9mIGxhbWJkYSBmdW5jdG9ycyB0aGF0IHJlc3VsdCBmcm9tIGV2ZW4gdGhlIHNpbXBsZXN0IGxhbWJkYSBleHByZXNzaW9ucyBhcmUgY3J5cHRpYy4gClVzdWFsbHkgdGhlIHByb2dyYW1tZXIgZG9lc24ndCBuZWVkIHRvIGRlYWwgd2l0aCB0aGUgbGFtYmRhIGZ1bmN0b3IgdHlwZXMgYXQgYWxsLCBidXQgaW4gdGhlIGNhc2Ugb2YgYW4gZXJyb3IgaW4gYSBsYW1iZGEgZXhwcmVzc2lvbiwgdGhlIGNvbXBpbGVyIHVzdWFsbHkgb3V0cHV0cyB0aGUgdHlwZXMgb2YgdGhlIGxhbWJkYSBmdW5jdG9ycyBpbnZvbHZlZC4gClRoaXMgY2FuIG1ha2UgdGhlIGVycm9yIG1lc3NhZ2VzIHZlcnkgbG9uZyBhbmQgZGlmZmljdWx0IHRvIGludGVycHJldCwgcGFydGljdWxhcmx5IGlmIHRoZSBjb21waWxlciBvdXRwdXRzIHRoZSB3aG9sZSBjaGFpbiBvZiB0ZW1wbGF0ZSBpbnN0YW50aWF0aW9ucy4KPC9wYXJhPgo8L2xpc3RpdGVtPgoKPGxpc3RpdGVtPgo8cGFyYT4KVGhlIEMrKyBTdGFuZGFyZCBzdWdnZXN0cyBhIHRlbXBsYXRlIG5lc3RpbmcgbGV2ZWwgb2YgMTcgdG8gaGVscCBkZXRlY3QgaW5maW5pdGUgcmVjdXJzaW9uLiAKQ29tcGxleCBsYW1iZGEgdGVtcGxhdGVzIGNhbiBlYXNpbHkgZXhjZWVkIHRoaXMgbGltaXQuIApNb3N0IGNvbXBpbGVycyBhbGxvdyBhIGdyZWF0ZXIgbnVtYmVyIG9mIG5lc3RlZCB0ZW1wbGF0ZXMsIGJ1dCBjb21tb25seSByZXF1aXJlIHRoZSBsaW1pdCBleHBsaWNpdGx5IGluY3JlYXNlZCB3aXRoIGEgY29tbWFuZCBsaW5lIGFyZ3VtZW50Lgo8L3BhcmE+CjwvbGlzdGl0ZW0+CjwvaXRlbWl6ZWRsaXN0PjwvcGFyYT4KCiAgICA8L3NlY3Rpb24+CgogICAgPHNlY3Rpb24+CiAgICAgIDx0aXRsZT5Qb3J0YWJpbGl0eTwvdGl0bGU+CiAgICAgIDxwYXJhPgpUaGUgQkxMIHdvcmtzIHdpdGggdGhlIGZvbGxvd2luZyBjb21waWxlcnMsIHRoYXQgaXMsIHRoZSBjb21waWxlcnMgYXJlIGNhcGFibGUgb2YgY29tcGlsaW5nIHRoZSB0ZXN0IGNhc2VzIHRoYXQgYXJlIGluY2x1ZGVkIHdpdGggdGhlIEJMTDoKCiAgICAgIDxpdGVtaXplZGxpc3Q+Cgk8bGlzdGl0ZW0+R0NDIDMuMC40Cgk8L2xpc3RpdGVtPgoJPGxpc3RpdGVtPktDQyA0LjBmIHdpdGggRURHIDIuNDMuMQoJPC9saXN0aXRlbT4KCTxsaXN0aXRlbT5HQ0MgMi45NiAoZmFpbHMgd2l0aCBvbmUgdGVzdCBjYXNlLCB0aGUgPGZpbGVuYW1lPmV4Y2VwdGlvbl90ZXN0LmNwcDwvZmlsZW5hbWU+IHJlc3VsdHMgaW4gYW4gaW50ZXJuYWwgY29tcGlsZXIgZXJyb3IuCikKCgk8L2xpc3RpdGVtPgogICAgICA8L2l0ZW1pemVkbGlzdD4KPC9wYXJhPgoKICAgICAgPHNlY3Rpb24+Cgk8dGl0bGU+VGVzdCBjb3ZlcmFnZTwvdGl0bGU+Cgo8cGFyYT5UaGUgZm9sbG93aW5nIGxpc3QgZGVzY3JpYmVzIHRoZSB0ZXN0IGZpbGVzIGluY2x1ZGVkIGFuZCB0aGUgZmVhdHVyZXMgdGhhdCBlYWNoIGZpbGUgY292ZXJzOgoKPGl0ZW1pemVkbGlzdD4KPGxpc3RpdGVtPgo8cGFyYT4KPGZpbGVuYW1lPmJpbmRfdGVzdHNfc2ltcGxlLmNwcDwvZmlsZW5hbWU+IDogQmluZCBleHByZXNzaW9ucyBvZiBkaWZmZXJlbnQgYXJpdGllcyBhbmQgdHlwZXMgb2YgdGFyZ2V0IGZ1bmN0aW9uczogZnVuY3Rpb24gcG9pbnRlcnMsIGZ1bmN0aW9uIG9iamVjdHMgYW5kIG1lbWJlciBmdW5jdGlvbnMuCkZ1bmN0aW9uIGNvbXBvc2l0aW9uIHdpdGggYmluZCBleHByZXNzaW9ucy48L3BhcmE+CjwvbGlzdGl0ZW0+Cgo8bGlzdGl0ZW0+CjxwYXJhPjxmaWxlbmFtZT5iaW5kX3Rlc3RzX3NpbXBsZV9mdW5jdGlvbl9yZWZlcmVuY2VzLmNwcDwvZmlsZW5hbWU+IDoKUmVwZWF0cyBhbGwgdGVzdHMgZnJvbSA8ZmlsZW5hbWUgbW9yZWluZm89Im5vbmUiPmJpbmRfdGVzdHNfc2ltcGxlLmNwcDwvZmlsZW5hbWU+IHdoZXJlIHRoZSB0YXJnZXQgZnVuY3Rpb24gaXMgYSBmdW5jdGlvbiBwb2ludGVyLCBidXQgdXNlcyBmdW5jdGlvbiByZWZlcmVuY2VzIGluc3RlYWQuCjwvcGFyYT48L2xpc3RpdGVtPgoKCSAgICAKPGxpc3RpdGVtPgo8cGFyYT48ZmlsZW5hbWU+YmluZF90ZXN0c19hZHZhbmNlZC5jcHA8L2ZpbGVuYW1lPiA6IENvbnRhaW5zIHRlc3RzIGZvciBuZXN0ZWQgYmluZCBleHByZXNzaW9ucywgPGxpdGVyYWw+dW5sYW1iZGE8L2xpdGVyYWw+LCA8bGl0ZXJhbD5wcm90ZWN0PC9saXRlcmFsPiwgPGxpdGVyYWw+Y29uc3RfcGFyYW1ldGVyczwvbGl0ZXJhbD4gYW5kIDxsaXRlcmFsPmJyZWFrX2NvbnN0PC9saXRlcmFsPi4KVGVzdHMgcGFzc2luZyBsYW1iZGEgZnVuY3RvcnMgYXMgYWN0dWFsIGFyZ3VtZW50cyB0byBvdGhlciBsYW1iZGEgZnVuY3RvcnMsIGN1cnJ5aW5nLCBhbmQgdXNpbmcgdGhlIDxsaXRlcmFsPnNpZzwvbGl0ZXJhbD4gdGVtcGxhdGUgdG8gc3BlY2lmeSB0aGUgcmV0dXJuIHR5cGUgb2YgYSBmdW5jdGlvbiBvYmplY3QuCjwvcGFyYT4KPC9saXN0aXRlbT4KCjxsaXN0aXRlbT4KPHBhcmE+CjxmaWxlbmFtZT5vcGVyYXRvcl90ZXN0c19zaW1wbGUuY3BwPC9maWxlbmFtZT4gOgpUZXN0cyB1c2luZyBhbGwgb3BlcmF0b3JzIHRoYXQgYXJlIG92ZXJsb2FkZWQgZm9yIGxhbWJkYSBleHByZXNzaW9ucywgdGhhdCBpcywgdW5hcnkgYW5kIGJpbmFyeSBhcml0aG1ldGljLCAKYml0d2lzZSwgCmNvbXBhcmlzb24sIApsb2dpY2FsLAppbmNyZW1lbnQgYW5kIGRlY3JlbWVudCwgCmNvbXBvdW5kLCAKYXNzaWdubWVudCwKc3Vic2NyaWN0LCAKYWRkcmVzcyBvZiwKZGVyZWZlcmVuY2UsIGFuZCBjb21tYSBvcGVyYXRvcnMuClRoZSBzdHJlYW1pbmcgbmF0dXJlIG9mIHNoaWZ0IG9wZXJhdG9ycyBpcyB0ZXN0ZWQsIGFzIHdlbGwgYXMgcG9pbnRlciBhcml0aG1ldGljIHdpdGggcGx1cyBhbmQgbWludXMgb3BlcmF0b3JzLgo8L3BhcmE+CjwvbGlzdGl0ZW0+CgkgICAgCjxsaXN0aXRlbT4KPHBhcmE+PGZpbGVuYW1lPm1lbWJlcl9wb2ludGVyX3Rlc3QuY3BwPC9maWxlbmFtZT4gOiBUaGUgcG9pbnRlciB0byBtZW1iZXIgb3BlcmF0b3IgaXMgY29tcGxleCBlbm91Z2ggdG8gd2FycmFudCBhIHNlcGFyYXRlIHRlc3QgZmlsZS4KPC9wYXJhPgo8L2xpc3RpdGVtPgoKPGxpc3RpdGVtPgo8cGFyYT4KPGZpbGVuYW1lPmNvbnRyb2xfc3RydWN0dXJlcy5jcHA8L2ZpbGVuYW1lPiA6ClRlc3RzIGZvciB0aGUgbG9vcGluZyBhbmQgaWYgY29uc3RydWN0cy4KPC9wYXJhPjwvbGlzdGl0ZW0+Cgo8bGlzdGl0ZW0+CjxwYXJhPgo8ZmlsZW5hbWU+c3dpdGNoX2NvbnN0cnVjdC5jcHA8L2ZpbGVuYW1lPiA6CkluY2x1ZGVzIHRlc3RzIGZvciBhbGwgc3VwcG9ydGVkIGFyaXRpZXMgb2YgdGhlIHN3aXRjaCBzdGF0ZW1lbnQsIGJvdGggd2l0aCBhbmQgd2l0aG91dCB0aGUgZGVmYXVsdCBjYXNlLgo8L3BhcmE+CjwvbGlzdGl0ZW0+Cgo8bGlzdGl0ZW0+CjxwYXJhPgo8ZmlsZW5hbWU+ZXhjZXB0aW9uX3Rlc3QuY3BwPC9maWxlbmFtZT4gOgpJbmNsdWRlcyB0ZXN0cyBmb3IgdGhyb3dpbmcgZXhjZXB0aW9ucyBhbmQgZm9yIHRyeS9jYXRjaCBjb25zdHJ1Y3RzIHdpdGggdmFyeWluZyBudW1iZXIgb2YgY2F0Y2ggYmxvY2tzLgo8L3BhcmE+CjwvbGlzdGl0ZW0+Cgo8bGlzdGl0ZW0+CjxwYXJhPgo8ZmlsZW5hbWU+Y29uc3RydWN0b3JfdGVzdHMuY3BwPC9maWxlbmFtZT4gOgpDb250YWlucyB0ZXN0cyBmb3IgPGxpdGVyYWw+Y29uc3RydWN0b3I8L2xpdGVyYWw+LCA8bGl0ZXJhbD5kZXN0cnVjdG9yPC9saXRlcmFsPiwgPGxpdGVyYWw+bmV3X3B0cjwvbGl0ZXJhbD4sIDxsaXRlcmFsPmRlbGV0ZV9wdHI8L2xpdGVyYWw+LCA8bGl0ZXJhbD5uZXdfYXJyYXk8L2xpdGVyYWw+IGFuZCA8bGl0ZXJhbD5kZWxldGVfYXJyYXk8L2xpdGVyYWw+Lgo8L3BhcmE+CjwvbGlzdGl0ZW0+Cgo8bGlzdGl0ZW0+CjxwYXJhPgo8ZmlsZW5hbWU+Y2FzdF90ZXN0LmNwcDwvZmlsZW5hbWU+IDogVGVzdHMgZm9yIHRoZSBmb3VyIGNhc3QgZXhwcmVzc2lvbnMsIGFzIHdlbGwgYXMgPGZpbGVuYW1lPnR5cGVpZDwvZmlsZW5hbWU+IGFuZCA8bGl0ZXJhbD5zaXplb2Y8L2xpdGVyYWw+Lgo8L3BhcmE+CjwvbGlzdGl0ZW0+Cgo8bGlzdGl0ZW0+CjxwYXJhPgo8ZmlsZW5hbWU+ZXh0ZW5kaW5nX3JldHVybl90eXBlX3RyYWl0cy5jcHA8L2ZpbGVuYW1lPiA6IFRlc3RzIGV4dGVuZGluZyB0aGUgcmV0dXJuIHR5cGUgZGVkdWN0aW9uIHN5c3RlbSBmb3IgdXNlciBkZWZpbmVkIHR5cGVzLgpDb250YWlucyBzZXZlcmFsIHVzZXIgZGVmaW5lZCBvcGVyYXRvcnMgYW5kIHRoZSBjb3JyZXNwb25kaW5nIHNwZWNpYWxpemF0aW9ucyBmb3IgdGhlIHJldHVybiB0eXBlIGRlZHVjdGlvbiB0ZW1wbGF0ZXMuCjwvcGFyYT4KPC9saXN0aXRlbT4KCjxsaXN0aXRlbT4KPHBhcmE+CjxmaWxlbmFtZT5pc19pbnN0YW5jZV9vZl90ZXN0LmNwcDwvZmlsZW5hbWU+IDogSW5jbHVkZXMgdGVzdHMgZm9yIGFuIGludGVybmFsbHkgdXNlZCB0cmFpdHMgdGVtcGxhdGUsIHdoaWNoIGNhbiBkZXRlY3Qgd2hldGhlciBhIGdpdmVuIHR5cGUgaXMgYW4gaW5zdGFuY2Ugb2YgYSBjZXJ0YWluIHRlbXBsYXRlIG9yIG5vdC4gCjwvcGFyYT48L2xpc3RpdGVtPgoKPGxpc3RpdGVtPgo8cGFyYT4KPGZpbGVuYW1lPmJsbF9hbmRfZnVuY3Rpb24uY3BwPC9maWxlbmFtZT4gOgpDb250YWlucyB0ZXN0cyBmb3IgdXNpbmcgPGxpdGVyYWw+Ym9vc3Q6OmZ1bmN0aW9uPC9saXRlcmFsPiB0b2dldGhlciB3aXRoIGxhbWJkYSBmdW5jdG9ycy4KPC9wYXJhPjwvbGlzdGl0ZW0+CgoJICA8L2l0ZW1pemVkbGlzdD4KCjwvcGFyYT4KCiAgICAgIDwvc2VjdGlvbj4KCiAgICA8L3NlY3Rpb24+CgoKPC9zZWN0aW9uPgoKCjxzZWN0aW9uPgo8dGl0bGU+UmVsYXRpb24gdG8gb3RoZXIgQm9vc3QgbGlicmFyaWVzPC90aXRsZT4KCjxzZWN0aW9uPgo8dGl0bGU+Qm9vc3QgRnVuY3Rpb248L3RpdGxlPgoKPHBhcmE+U29tZXRpbWVzIGl0IGlzIGNvbnZlbmllbnQgdG8gc3RvcmUgbGFtYmRhIGZ1bmN0b3JzIGluIHZhcmlhYmxlcy4KSG93ZXZlciwgdGhlIHR5cGVzIG9mIGV2ZW4gdGhlIHNpbXBsZXN0IGxhbWJkYSBmdW5jdG9ycyBhcmUgbG9uZyBhbmQgdW53aWVsZHksIGFuZCBpdCBpcyBpbiBnZW5lcmFsIHVuZmVhc2libGUgdG8gZGVjbGFyZSB2YXJpYWJsZXMgd2l0aCBsYW1iZGEgZnVuY3RvciB0eXBlcy4KPGVtcGhhc2lzPlRoZSBCb29zdCBGdW5jdGlvbiBsaWJyYXJ5PC9lbXBoYXNpcz4gPHhyZWYgbGlua2VuZD0iY2l0OmJvb3N0OjpmdW5jdGlvbiIvPiBkZWZpbmVzIHdyYXBwZXJzIGZvciBhcmJpdHJhcnkgZnVuY3Rpb24gb2JqZWN0cywgZm9yIGV4YW1wbGUgCmxhbWJkYSBmdW5jdG9yczsgYW5kIHRoZXNlIHdyYXBwZXJzIGhhdmUgdHlwZXMgdGhhdCBhcmUgZWFzeSB0byB0eXBlIG91dC4KCkZvciBleGFtcGxlOgoKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVtib29zdDo6ZnVuY3Rpb248aW50KGludCwgaW50KT4gZiA9IF8xICsgXzI7CmJvb3N0OjpmdW5jdGlvbjxpbnQmKGludCYpPiBnID0gKF8xICs9IDEwKTsKaW50IGkgPSAxLCBqID0gMjsKZihpLCBqKTsgLy8gcmV0dXJucyAzCmcoaSk7ICAgIC8vIHNldHMgaSB0byA9IDExO11dPgo8L3Byb2dyYW1saXN0aW5nPgoKVGhlIHJldHVybiBhbmQgcGFyYW1ldGVyIHR5cGVzIG9mIHRoZSB3cmFwcGVkIGZ1bmN0aW9uIG9iamVjdCBtdXN0IGJlIHdyaXR0ZW4gZXhwbGljaWx0eSBhcyB0aGUgdGVtcGxhdGUgYXJndW1lbnQgdG8gdGhlIHdyYXBwZXIgdGVtcGxhdGUgPGxpdGVyYWw+Ym9vc3Q6OmZ1bmN0aW9uPC9saXRlcmFsPjsgZXZlbiB3aGVuIGxhbWJkYSBmdW5jdG9ycywgd2hpY2ggb3RoZXJ3aXNlIGhhdmUgZ2VuZXJpYyBwYXJhbWV0ZXJzLCBhcmUgd3JhcHBlZC4KV3JhcHBpbmcgYSBmdW5jdGlvbiBvYmplY3Qgd2l0aCA8bGl0ZXJhbD5ib29zdDo6ZnVuY3Rpb248L2xpdGVyYWw+IGludHJvZHVjZXMgYSBwZXJmb3JtYW5jZSBjb3N0IGNvbXBhcmFibGUgdG8gdmlydHVhbCBmdW5jdGlvbiBkaXNwYXRjaCwgdGhvdWdoIHZpcnR1YWwgZnVuY3Rpb25zIGFyZSBub3QgYWN0dWFsbHkgdXNlZC4KCk5vdGUgdGhhdCBzdG9yaW5nIGxhbWJkYSBmdW5jdG9ycyBpbnNpZGUgPGxpdGVyYWw+Ym9vc3Q6OmZ1bmN0aW9uPC9saXRlcmFsPiAKaW50cm9kdWNlcyBhIGRhbmdlci4KQ2VydGFpbiB0eXBlcyBvZiBsYW1iZGEgZnVuY3RvcnMgbWF5IHN0b3JlIHJlZmVyZW5jZXMgdG8gdGhlIGJvdW5kIAphcmd1bWVudHMsIGluc3RlYWQgYXMgdGFraW5nIGNvcGllcyBvZiB0aGUgYXJndW1lbnRzIG9mIHRoZSBsYW1iZGEgZXhwcmVzc2lvbi4KV2hlbiB0ZW1wb3JhcnkgbGFtYmRhIGZ1bmN0b3Igb2JqZWN0cyBhcmUgdXNlZCAKaW4gU1RMIGFsZ29yaXRobSBpbnZvY2F0aW9ucyB0aGlzIGlzIGFsd2F5cyBzYWZlLCBhcyB0aGUgbGFtYmRhIGZ1bmN0b3IgZ2V0cyAKZGVzdHJ1Y3RlZCBpbW1lZGlhdGVseSBhZnRlciB0aGUgU1RMIGFsZ29ydGlobSBpbnZvY2F0aW9uIGlzIGNvbXBsZXRlZC4KCkhvd2V2ZXIsIGEgbGFtYmRhIGZ1bmN0b3Igd3JhcHBlZCBpbnNpZGUgPGxpdGVyYWw+Ym9vc3Q6OmZ1bmN0aW9uPC9saXRlcmFsPiAKbWF5IGNvbnRpbnVlIHRvIGV4aXN0IGxvbmdlciwgY3JlYXRpbmcgdGhlIHBvc3NpYmlsaXR5IG9mIGRhbmdsaW5nIHJlZmVyZW5jZXMuCkZvciBleGFtcGxlOgoKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVtpbnQqIHN1bSA9IG5ldyBpbnQoKTsKKnN1bSA9IDA7CmJvb3N0OjpmdW5jdGlvbjxpbnQmKGludCk+IGNvdW50ZXIgPSAqc3VtICs9IF8xOwpjb3VudGVyKDUpOyAvLyBvaywgKnN1bSA9IDU7CmRlbGV0ZSBzdW07IApjb3VudGVyKDMpOyAvLyBlcnJvciwgKnN1bSBkb2VzIG5vdCBleGlzdCBhbnltb3JlXV0+CjwvcHJvZ3JhbWxpc3Rpbmc+Cgo8L3BhcmE+Cgo8L3NlY3Rpb24+Cgo8c2VjdGlvbj4KPHRpdGxlPkJvb3N0IEJpbmQ8L3RpdGxlPgo8cGFyYT4KPGVtcGhhc2lzPlRoZSBCb29zdCBCaW5kPC9lbXBoYXNpcz4gPHhyZWYgbGlua2VuZD0iY2l0OmJvb3N0OjpiaW5kIi8+IGxpYnJhcnkgaGFzIHBhcnRpYWxseSBvdmVybGFwcGluZyBmdW5jdGlvbmFsaXR5IHdpdGggdGhlIEJMTC4gCkJhc2ljYWxseSwgdGhlIEJvb3N0IEJpbmQgbGlicmFyeSAoQkIgaW4gdGhlIHNlcXVlbCkgaW1wbGVtZW50cyB0aGUgYmluZCBleHByZXNzaW9uIHBhcnQgb2YgQkxMLgpUaGVyZSBhcmUsIGhvd2V2ZXIsIHNvbWUgc2VtYW50aWNhbCBkaWZmZXJlcmVuY2VzLgo8L3BhcmE+CjxwYXJhPgpUaGUgQkxMIGFuZCBCQiBldm9sdmVkIHNlcGFyYXRlbHksIGFuZCBoYXZlIGRpZmZlcmVudCBpbXBsZW1lbnRhdGlvbnMuIApUaGlzIG1lYW5zIHRoYXQgdGhlIGJpbmQgZXhwcmVzc2lvbnMgZnJvbSB0aGUgQkIgY2Fubm90IGJlIHVzZWQgd2l0aGluIApiaW5kIGV4cHJlc3Npb25zLCBvciB3aXRoaW4gb3RoZXIgdHlwZSBvZiBsYW1iZGEgZXhwcmVzc2lvbnMsIG9mIHRoZSBCTEwuClRoZSBzYW1lIGhvbGRzIGZvciB1c2luZyBCTEwgYmluZCBleHByZXNzaW9ucyBpbiB0aGUgQkIuClRoZSBsaWJyYXJpZXMgY2FuIGNvZXhpc3QsIGhvd2V2ZXIsIGFzCnRoZSBuYW1lcyBvZiB0aGUgQkIgbGlicmFyeSBhcmUgaW4gPGxpdGVyYWw+Ym9vc3Q8L2xpdGVyYWw+IG5hbWVzcGFjZSwgCndoZXJlYXMgdGhlIEJMTCBuYW1lcyBhcmUgaW4gPGxpdGVyYWw+Ym9vc3Q6OmxhbWJkYTwvbGl0ZXJhbD4gbmFtZXNwYWNlLgo8L3BhcmE+Cgo8cGFyYT4KVGhlIEJMTCByZXF1aXJlcyBhIGNvbXBpbGVyIHRoYXQgaXMgcmVhc29uYWJseSBjb25mb3JtYW50IHRvIHRoZSAKQysrIHN0YW5kYXJkLCB3aGVyZWFzIHRoZSBCQiBsaWJyYXJ5IGlzIG1vcmUgcG9ydGFibGUsIGFuZCB3b3JrcyB3aXRoIAphIGxhcmdlciBzZXQgb2YgY29tcGlsZXJzLiAKPC9wYXJhPgoKPHBhcmE+ClRoZSBmb2xsb3dpbmcgdHdvIHNlY3Rpb25zIGRlc2NyaWJlIHdoYXQgYXJlIHRoZSBzZW1hbnRpYyBkaWZmZXJlbmNlcyAKYmV0d2VlbiB0aGUgYmluZCBleHByZXNzaW9ucyBpbiBCQiBhbmQgQkxMLgo8L3BhcmE+CgoKCgo8c2VjdGlvbj4KPHRpdGxlPkZpcnN0IGFyZ3VtZW50IG9mIGJpbmQgZXhwcmVzc2lvbjwvdGl0bGU+CgpJbiBCQiB0aGUgZmlyc3QgYXJndW1lbnQgb2YgdGhlIGJpbmQgZXhwcmVzc2lvbiwgdGhlIHRhcmdldCBmdW5jdGlvbiwgCmlzIHRyZWF0ZWQgZGlmZmVyZW50bHkgZnJvbSB0aGUgb3RoZXIgYXJndW1lbnRzLCAKYXMgbm8gYXJndW1lbnQgc3Vic3RpdHV0aW9uIHRha2VzIHBsYWNlIHdpdGhpbiB0aGF0IGFyZ3VtZW50LgpJbiBCTEwgdGhlIGZpcnN0IGFyZ3VtZW50IGlzIG5vdCBhIHNwZWNpYWwgY2FzZSBpbiB0aGlzIHJlc3BlY3QuCgpGb3IgZXhhbXBsZToKCjxwcm9ncmFtbGlzdGluZz4KPCFbQ0RBVEFbdGVtcGxhdGU8Y2xhc3MgRj4KaW50IGZvbyhjb25zdCBGJiBmKSB7CiAgaW50IHg7CiAgLi4KICBiaW5kKGYsIF8xKSh4KTsKICAuLi4KfV1dPgo8L3Byb2dyYW1saXN0aW5nPgoKPHByb2dyYW1saXN0aW5nPgo8IVtDREFUQVtpbnQgYmFyKGludCwgaW50KTsKbmVzdGVkKGJpbmQoYmFyLCAxLCBfMSkpO11dPgo8L3Byb2dyYW1saXN0aW5nPgoKVGhlIGJpbmQgZXhwcmVzc2lvbiBpbnNpZGUgPGxpdGVyYWw+Zm9vPC9saXRlcmFsPiBiZWNvbWVzOgo8cHJvZ3JhbWxpc3Rpbmc+CmJpbmQoYmluZChiYXIsIDEsIF8xKSwgXzEpKHgpCjwvcHJvZ3JhbWxpc3Rpbmc+CgpUaGUgQkxMIGludGVycHJldGVzIHRoaXMgYXM6Cjxwcm9ncmFtbGlzdGluZz4KYmFyKDEsIHgpKHgpCjwvcHJvZ3JhbWxpc3Rpbmc+CndoZXJlYXMgdGhlIEJCIGxpYnJhcnkgYXMKPHByb2dyYW1saXN0aW5nPgpiYXIoMSwgeCkKPC9wcm9ncmFtbGlzdGluZz4KClRvIGdldCB0aGlzIGZ1bmN0aW9uYWxpdHkgaW4gQkxMLCB0aGUgYmluZCBleHByZXNzaW9uIGluc2lkZSB0aGUgPGxpdGVyYWwgbW9yZWluZm89Im5vbmUiPmZvbzwvbGl0ZXJhbD4gZnVuY3Rpb24gY2FuIGJlIHdyaXR0ZW4gYXM6Cjxwcm9ncmFtbGlzdGluZz4KYmluZCh1bmxhbWJkYShmKSwgXzEpKHgpOwo8L3Byb2dyYW1saXN0aW5nPgphcyBleHBsYWluZWQgaW4gPHhyZWYgbGlua2VuZCA9ICJsYW1iZGEudW5sYW1iZGEiLz4uIAoKPC9zZWN0aW9uPgoKCgoKPHBhcmE+ClRoZSBCQiBsaWJyYXJ5IHN1cHBvcnRzIHVwIHRvIG5pbmUgcGxhY2Vob2xkZXJzLCB3aGlsZSB0aGUgQkxMIApkZWZpbmVzIG9ubHkgdGhyZWUgcGxhY2Vob2xkZXJzLiAKVGhlIHJhdGlvbmFsZSBmb3Igbm90IHByb3ZpZGluZyBtb3JlLCBpcyB0aGF0IHRoZSBoaWdoZXN0IGFyaXR5IG9mIHRoZQpmdW5jdGlvbiBvYmplY3RzIGFjY2VwdGVkIGJ5IGFueSBTVEwgYWxnb3JpdGhtIGlzIHR3by4gClRoZSBwbGFjZWhvbGRlciBjb3VudCBpcyBlYXN5IHRvIGluY3JlYXNlIGluIHRoZSBCQiBsaWJyYXJ5LgpJbiBCTEwgaXQgaXMgcG9zc2libGUsIGJ1dCBtb3JlIGxhYm9yb3VzLgpUaGUgQkxMIGN1cnJlbnRseSBwYXNzZXMgdGhlIGFjdHVhbCBhcmd1bWVudHMgdG8gdGhlIGxhbWJkYSBmdW5jdG9ycwppbnRlcm5hbGx5IGp1c3QgYXMgdGhleSBhcmUgYW5kIGRvZXMgbm90IHdyYXAgdGhlbSBpbnNpZGUgYSB0dXBsZSBvYmplY3QuClRoZSByZWFzb24gZm9yIHRoaXMgaXMgdGhhdCBzb21lIHdpZGVseSB1c2VkIGNvbXBpbGVycyBhcmUgbm90IGNhcGFibGUKb2Ygb3B0aW1pemluZyB0aGUgaW50ZXJtZWRpYXRlIHR1cGxlIG9iamVjdHMgYXdheS4gClRoZSBjcmVhdGlvbiBvZiB0aGUgaW50ZXJtZWRpYXRlIHR1cGxlcyB3b3VsZCBjYXVzZSBhIHNpZ25pZmljYW50CnBlcmZvcm1hbmNlIGhpdCwgcGFydGljdWxhcmx5IGZvciB0aGUgc2ltcGxlc3QgKGFuZCB0aHVzIHRoZSBtb3N0IGNvbW1vbikgCmxhbWJkYSBmdW5jdG9ycy4gIApXZSBhcmUgd29ya2luZyBvbiBhIGh5YnJpZCBhcHByb2FjaCwgd2hpY2ggd2lsbCBhbGxvdyBtb3JlIHBsYWNlaG9sZGVycwpidXQgbm90IGNvbXByb21pc2UgdGhlIHBlcmZvcm1hbmNlIG9mIHNpbXBsZSBsYW1iZGEgZnVuY3RvcnMuCjwvcGFyYT4KCjwvc2VjdGlvbj4KCiAgPC9zZWN0aW9uPgoKCjxzZWN0aW9uPgo8dGl0bGU+Q29udHJpYnV0b3JzPC90aXRsZT4KClRoZSBtYWluIGJvZHkgb2YgdGhlIGxpYnJhcnkgd2FzIHdyaXR0ZW4gYnkgSmFha2tvIErkcnZpIGFuZCBHYXJ5IFBvd2VsbC4KV2UndmUgZ290IG91dHNpZGUgaGVscCwgc3VnZ2VzdGlvbnMgYW5kIGlkZWFzIGZyb20gSmVyZW15IFNpZWssIFBldGVyIEhpZ2xleSwgUGV0ZXIgRGltb3YsIFZhbGVudGluIEJvbm5hcmQsIFdpbGxpYW0gS2VtcGYuCldlIHdvdWxkIHBhcnRpY3VsYXJseSBsaWtlIHRvIG1lbnRpb24gSm9lbCBkZSBHdXptYW5uIGFuZCBoaXMgd29yayB3aXRoIApQaG9lbml4IHdoaWNoIGhhcyBpbmZsdWVuY2VkIEJMTCBzaWduaWZpY2FudGx5LCBtYWtpbmcgaXQgY29uc2lkZXJhYmx5IHNpbXBsZXIgCnRvIGV4dGVuZCB0aGUgbGlicmFyeSB3aXRoIG5ldyBmZWF0dXJlcy4KCjwvc2VjdGlvbj4KCgoKPHNlY3Rpb24+Cjx0aXRsZT5SYXRpb25hbGUgZm9yIHNvbWUgb2YgdGhlIGRlc2lnbiBkZWNpc2lvbnM8L3RpdGxlPgoKPHNlY3Rpb24gaWQ9ImxhbWJkYS53aHlfd2Vha19hcml0eSI+Cjx0aXRsZT4KTGFtYmRhIGZ1bmN0b3IgYXJpdHkKPC90aXRsZT4KCjxwYXJhPgpUaGUgaGlnaGVzdCBwbGFjZWhvbGRlciBpbmRleCBpbiBhIGxhbWJkYSBleHByZXNzaW9uIGRldGVybWluZXMgdGhlIGFyaXR5IG9mIHRoZSByZXN1bHRpbmcgZnVuY3Rpb24gb2JqZWN0LgpIb3dldmVyLCB0aGlzIGlzIGp1c3QgdGhlIG1pbmltYWwgYXJpdHksIGFzIHRoZSBmdW5jdGlvbiBvYmplY3QgY2FuIHRha2UgYXJiaXRyYXJpbHkgbWFueSBhcmd1bWVudHM7IHRob3NlIG5vdCBuZWVkZWQgYXJlIGRpc2NhcmRlZC4KQ29uc2lkZXIgdGhlIHR3byBiaW5kIGV4cHJlc3Npb25zIGFuZCB0aGVpciBpbnZvY2F0aW9ucyBiZWxvdzoKCjxwcm9ncmFtbGlzdGluZz4KYmluZChnLCBfMywgXzMsIF8zKSh4LCB5LCB6KTsgCmJpbmQoZywgXzEsIF8xLCBfMSkoeCwgeSwgeik7IAo8L3Byb2dyYW1saXN0aW5nPgoKVGhpcyBmaXJzdCBsaW5lIGRpc2NhcmRzIGFyZ3VtZW50cyA8bGl0ZXJhbD54PC9saXRlcmFsPiBhbmQKPGxpdGVyYWw+eTwvbGl0ZXJhbD4sIGFuZCBtYWtlcyB0aGUgY2FsbDoKPHByb2dyYW1saXN0aW5nPgpnKHosIHosIHopIAo8L3Byb2dyYW1saXN0aW5nPgp3aGVyZWFzIHRoZSBzZWNvbmQgbGluZSBkaXNjYXJkcyBhcmd1bWVudHMgPGxpdGVyYWw+eTwvbGl0ZXJhbD4gYW5kCjxsaXRlcmFsPno8L2xpdGVyYWw+LCBhbmQgY2FsbHM6Cjxwcm9ncmFtbGlzdGluZz4KZyh4LCB4LCB4KQo8L3Byb2dyYW1saXN0aW5nPgpJbiBlYXJsaWVyIHZlcnNpb25zIG9mIHRoZSBsaWJyYXJ5LCB0aGUgbGF0dGVyIGxpbmUgcmVzdWx0ZWQgaW4gYSBjb21waWxlIAp0aW1lIGVycm9yLgoKVGhpcyBpcyBiYXNpY2FsbHkgYSB0cmFkZW9mZiBiZXR3ZWVuIHNhZmV0eSBhbmQgZmxleGliaWxpdHksIGFuZCB0aGUgaXNzdWUKd2FzIGV4dGVuc2l2ZWx5IGRpc2N1c3NlZCBkdXJpbmcgdGhlIEJvb3N0IHJldmlldyBwZXJpb2Qgb2YgdGhlIGxpYnJhcnkuClRoZSBtYWluIHBvaW50cyBmb3IgdGhlIDxlbXBoYXNpcz5zdHJpY3QgYXJpdHk8L2VtcGhhc2lzPiBjaGVja2luZwp3YXMgdGhhdCBpdCBtaWdodApjYXRjaCBhIHByb2dyYW1taW5nIGVycm9yIGF0IGFuIGVhcmxpZXIgdGltZSBhbmQgdGhhdCBhIGxhbWJkYSBleHByZXNzaW9uIHRoYXQKZXhwbGljaXRseSBkaXNjYXJkcyBpdHMgYXJndW1lbnRzIGlzIGVhc3kgdG8gd3JpdGU6Cjxwcm9ncmFtbGlzdGluZz4KKF8zLCBiaW5kKGcsIF8xLCBfMSwgXzEpKSh4LCB5LCB6KTsKPC9wcm9ncmFtbGlzdGluZz4KVGhpcyBsYW1iZGEgZXhwcmVzc2lvbiB0YWtlcyB0aHJlZSBhcmd1bWVudHMuClRoZSBsZWZ0LWhhbmQgYXJndW1lbnQgb2YgdGhlIGNvbW1hIG9wZXJhdG9yIGRvZXMgbm90aGluZywgYW5kIGFzIGNvbW1hIApyZXR1cm5zIHRoZSByZXN1bHQgb2YgZXZhbHVhdGluZyB0aGUgcmlnaHQtaGFuZCBhcmd1bWVudCB3ZSBlbmQgdXAgd2l0aCAKdGhlIGNhbGwKPGxpdGVyYWw+Zyh4LCB4LCB4KTwvbGl0ZXJhbD4KZXZlbiB3aXRoIHRoZSBzdHJpY3QgYXJpdHkuCjwvcGFyYT4KCjxwYXJhPgpUaGUgbWFpbiBwb2ludHMgYWdhaW5zdCB0aGUgc3RyaWN0IGFyaXR5IGNoZWNraW5nIHdlcmUgdGhhdCB0aGUgbmVlZCB0byAKZGlzY2FyZCBhcmd1bWVudHMgaXMgY29tbW9ucGxhY2UsIGFuZCBzaG91bGQgdGhlcmVmb3JlIGJlIHN0cmFpZ2h0Zm9yd2FyZCwgCmFuZCB0aGF0IHN0cmljdCBhcml0eSBjaGVja2luZyBkb2VzIG5vdCByZWFsbHkgYnV5IHRoYXQgbXVjaCBtb3JlIHNhZmV0eSwgCnBhcnRpY3VsYXJseSBhcyBpdCBpcyBub3Qgc3ltbWV0cmljLgpGb3IgZXhhbXBsZSwgaWYgdGhlIHByb2dyYW1tZXIgd2FudGVkIHRvIHdyaXRlIHRoZSBleHByZXNzaW9uIAo8bGl0ZXJhbD5fMSArIF8yPC9saXRlcmFsPiBidXQgbWlzdGFrZW5seSB3cm90ZSA8bGl0ZXJhbD5fMSArIDI8L2xpdGVyYWw+LCAKd2l0aCBzdHJpY3QgYXJpdHkgY2hlY2tpbmcsIHRoZSBjb21wbGllciB3b3VsZCBzcG90IHRoZSBlcnJvci4KSG93ZXZlciwgaWYgdGhlIGVycm9uZW91cyBleHByZXNzaW9uIHdhcyA8bGl0ZXJhbD4xICsgXzI8L2xpdGVyYWw+IGluc3RlYWQsCnRoZSBlcnJvciB3b3VsZCBnbyB1bm5vdGljZWQuCkZ1cnRoZXJtb3JlLCB3ZWFrIGFyaXR5IGNoZWNraW5nIHNpbXBsaWZpZXMgdGhlIGltcGxlbWVudGF0aW9uIGEgYml0LgpGb2xsb3dpbmcgdGhlIHJlY29tbWVuZGF0aW9uIG9mIHRoZSBCb29zdCByZXZpZXcsIHN0cmljdCBhcml0eSBjaGVja2luZyAKd2FzIGRyb3BwZWQuCjwvcGFyYT4KCjwvc2VjdGlvbj4KCjwvc2VjdGlvbj4KCgoKPGJpYmxpb2dyYXBoeT4KCjxiaWJsaW9lbnRyeSBpZD0iY2l0OnN0ZXBhbm92Ojk0Ij4KPGFiYnJldj5TVEw5NDwvYWJicmV2Pgo8YXV0aG9yZ3JvdXA+CjxhdXRob3I+CjxzdXJuYW1lPlN0ZXBhbm92PC9zdXJuYW1lPgo8Zmlyc3RuYW1lPkEuIEEuPC9maXJzdG5hbWU+CjwvYXV0aG9yPgo8YXV0aG9yPgo8c3VybmFtZT5MZWU8L3N1cm5hbWU+CjxmaXJzdG5hbWU+TS48L2ZpcnN0bmFtZT4KPC9hdXRob3I+CjwvYXV0aG9yZ3JvdXA+ICAgICAgCjx0aXRsZT5UaGUgU3RhbmRhcmQgVGVtcGxhdGUgTGlicmFyeTwvdGl0bGU+CjxvcmduYW1lPkhld2xldHQtUGFja2FyZCBMYWJvcmF0b3JpZXM8L29yZ25hbWU+CjxwdWJkYXRlPjE5OTQ8L3B1YmRhdGU+CjxiaWJsaW9taXNjPgo8dWxpbmsgdXJsPSJodHRwOi8vd3d3LmhwbC5ocC5jb20vdGVjaHJlcG9ydHMiPnd3dy5ocGwuaHAuY29tL3RlY2hyZXBvcnRzPC91bGluaz4KPC9iaWJsaW9taXNjPgo8L2JpYmxpb2VudHJ5PgoKPGJpYmxpb2VudHJ5IGlkPSJjaXQ6c2dpOjAyIj4KPGFiYnJldj5TR0kwMjwvYWJicmV2Pgo8dGl0bGU+VGhlIFNHSSBTdGFuZGFyZCBUZW1wbGF0ZSBMaWJyYXJ5PC90aXRsZT4KPHB1YmRhdGU+MjAwMjwvcHViZGF0ZT4KPGJpYmxpb21pc2M+PHVsaW5rIHVybD0iaHR0cDovL3d3dy5zZ2kuY29tL3RlY2gvc3RsLyI+d3d3LnNnaS5jb20vdGVjaC9zdGwvPC91bGluaz48L2JpYmxpb21pc2M+Cgo8L2JpYmxpb2VudHJ5PgogICAgCjxiaWJsaW9lbnRyeSBpZD0iY2l0OmMrKzo5OCI+CjxhYmJyZXY+QysrOTg8L2FiYnJldj4KPHRpdGxlPkludGVybmF0aW9uYWwgU3RhbmRhcmQsIFByb2dyYW1taW5nIExhbmd1YWdlcyAmbmRhc2g7IEMrKzwvdGl0bGU+CjxzdWJ0aXRsZT5JU08vSUVDOjE0ODgyPC9zdWJ0aXRsZT4KPHB1YmRhdGU+MTk5ODwvcHViZGF0ZT4KPC9iaWJsaW9lbnRyeT4KCgo8YmlibGlvZW50cnkgaWQ9ImNpdDpqYXJ2aTo5OSI+CjxhYmJyZXY+SuRyOTk8L2FiYnJldj4KCjxhcnRpY2xlaW5mbz4KPGF1dGhvcj4KPHN1cm5hbWU+SuRydmk8L3N1cm5hbWU+CjxmaXJzdG5hbWU+SmFha2tvPC9maXJzdG5hbWU+CjwvYXV0aG9yPgo8dGl0bGU+QysrIEZ1bmN0aW9uIE9iamVjdCBCaW5kZXJzIE1hZGUgRWFzeTwvdGl0bGU+CjwvYXJ0aWNsZWluZm8+Cgo8dGl0bGU+TGVjdHVyZSBOb3RlcyBpbiBDb21wdXRlciBTY2llbmNlPC90aXRsZT4KPHZvbHVtZW51bT4xOTc3PC92b2x1bWVudW0+CjxwdWJsaXNoZXJuYW1lPlNwcmluZ2VyPC9wdWJsaXNoZXJuYW1lPgoKPHB1YmRhdGU+MjAwMDwvcHViZGF0ZT4KPC9iaWJsaW9lbnRyeT4KCgoKPGJpYmxpb2VudHJ5IGlkPSJjaXQ6amFydmk6MDAiPgo8YWJicmV2PkrkcjAwPC9hYmJyZXY+CjxhdXRob3I+CjxzdXJuYW1lPkrkcnZpPC9zdXJuYW1lPgo8Zmlyc3RuYW1lPkphYWtrbzwvZmlyc3RuYW1lPgo8L2F1dGhvcj4KPGF1dGhvcj4KPGZpcnN0bmFtZT5HYXJ5PC9maXJzdG5hbWU+CjxzdXJuYW1lPlBvd2VsbDwvc3VybmFtZT4KPC9hdXRob3I+Cjx0aXRsZT5UaGUgTGFtYmRhIExpYnJhcnkgOiBMYW1iZGEgQWJzdHJhY3Rpb24gaW4gQysrPC90aXRsZT4KICAgICAgPG9yZ25hbWU+VHVya3UgQ2VudHJlIGZvciBDb21wdXRlciBTY2llbmNlPC9vcmduYW1lPgo8YmlibGlvbWlzYz5UZWNobmljYWwgUmVwb3J0IDwvYmlibGlvbWlzYz4KICAgICAgPGlzc3VlbnVtPjM3ODwvaXNzdWVudW0+CjxwdWJkYXRlPjIwMDA8L3B1YmRhdGU+CjxiaWJsaW9taXNjPjx1bGluayB1cmw9Imh0dHA6Ly93d3cudHVjcy5maS9QdWJsaWNhdGlvbnMvdGVjaHJlcG9ydHMvVFIzNzgucGhwIj53d3cudHVjcy5maS9wdWJsaWNhdGlvbnM8L3VsaW5rPjwvYmlibGlvbWlzYz4KCgo8L2JpYmxpb2VudHJ5PgoKCjxiaWJsaW9lbnRyeSBpZD0iY2l0OmphcnZpOjAxIj4KPGFiYnJldj5K5HIwMTwvYWJicmV2Pgo8YXV0aG9yPgo8c3VybmFtZT5K5HJ2aTwvc3VybmFtZT4KPGZpcnN0bmFtZT5KYWFra288L2ZpcnN0bmFtZT4KPC9hdXRob3I+CjxhdXRob3I+CjxmaXJzdG5hbWU+R2FyeTwvZmlyc3RuYW1lPgo8c3VybmFtZT5Qb3dlbGw8L3N1cm5hbWU+CjwvYXV0aG9yPgo8dGl0bGU+VGhlIExhbWJkYSBMaWJyYXJ5IDogTGFtYmRhIEFic3RyYWN0aW9uIGluIEMrKzwvdGl0bGU+CiAgICAgIDxjb25mZ3JvdXA+Cgk8Y29uZnRpdGxlPlNlY29uZCAgV29ya3Nob3Agb24gQysrIFRlbXBsYXRlIFByb2dyYW1taW5nPC9jb25mdGl0bGU+Cgk8YWRkcmVzcz5UYW1wYSBCYXksIE9PUFNMQScwMTwvYWRkcmVzcz4KICAgICAgPC9jb25mZ3JvdXA+CjxwdWJkYXRlPjIwMDE8L3B1YmRhdGU+CjxiaWJsaW9taXNjPjx1bGluayB1cmw9Imh0dHA6Ly93d3cub29udW1lcmljcy5vcmcvdG1wdzAxLyI+d3d3Lm9vbnVtZXJpY3Mub3JnL3RtcHcwMS88L3VsaW5rPjwvYmlibGlvbWlzYz4KPC9iaWJsaW9lbnRyeT4KCjxiaWJsaW9lbnRyeSBpZD0iY2l0OmphcnZpOjAzIj4KPGFiYnJldj5K5HIwMzwvYWJicmV2PgoKPGFydGljbGVpbmZvPgoKPGF1dGhvcj4KPHN1cm5hbWU+SuRydmk8L3N1cm5hbWU+CjxmaXJzdG5hbWU+SmFha2tvPC9maXJzdG5hbWU+CjwvYXV0aG9yPgoKPGF1dGhvcj4KPGZpcnN0bmFtZT5HYXJ5PC9maXJzdG5hbWU+CjxzdXJuYW1lPlBvd2VsbDwvc3VybmFtZT4KPC9hdXRob3I+Cgo8YXV0aG9yPgo8Zmlyc3RuYW1lPkFuZHJldzwvZmlyc3RuYW1lPgo8c3VybmFtZT5MdW1zZGFpbmU8L3N1cm5hbWU+CjwvYXV0aG9yPgo8dGl0bGU+VGhlIExhbWJkYSBMaWJyYXJ5IDogdW5uYW1lZCBmdW5jdGlvbnMgaW4gQysrPC90aXRsZT4KCjwvYXJ0aWNsZWluZm8+Cgo8dGl0bGU+U29mdHdhcmUgLSBQcmFjdGljZSBhbmQgRXhwcmVpZW5jZTwvdGl0bGU+Cjx2b2x1bWVudW0+MzM6MjU5LTI5MTwvdm9sdW1lbnVtPgoKCjxwdWJkYXRlPjIwMDM8L3B1YmRhdGU+CjwvYmlibGlvZW50cnk+CgoKPGJpYmxpb2VudHJ5IGlkPSJjaXQ6Ym9vc3Q6OnR1cGxlIj4KPGFiYnJldj50dXBsZTwvYWJicmV2Pgo8dGl0bGU+VGhlIEJvb3N0IFR1cGxlIExpYnJhcnk8L3RpdGxlPgo8YmlibGlvbWlzYz48dWxpbmsgdXJsPSJodHRwOi8vd3d3LmJvb3N0Lm9yZy9saWJzL3R1cGxlL2RvYy90dXBsZV91c2Vyc19ndWlkZS5odG1sIj53d3cuYm9vc3Qub3JnL2xpYnMvdHVwbGUvZG9jL3R1cGxlX3VzZXJzX2d1aWRlLmh0bWw8L3VsaW5rPgo8L2JpYmxpb21pc2M+CjxwdWJkYXRlPjIwMDI8L3B1YmRhdGU+CjwvYmlibGlvZW50cnk+Cgo8YmlibGlvZW50cnkgaWQ9ImNpdDpib29zdDo6dHlwZV90cmFpdHMiPgo8YWJicmV2PnR5cGVfdHJhaXRzPC9hYmJyZXY+Cjx0aXRsZT5UaGUgQm9vc3QgdHlwZV90cmFpdHM8L3RpdGxlPgo8YmlibGlvbWlzYz48dWxpbmsgdXJsPSJodHRwOi8vd3d3LmJvb3N0Lm9yZy9saWJzL3R5cGVfdHJhaXRzL2luZGV4Lmh0bSI+d3d3LmJvb3N0Lm9yZy9saWJzL3R5cGVfdHJhaXRzLzwvdWxpbms+CjwvYmlibGlvbWlzYz4KPHB1YmRhdGU+MjAwMjwvcHViZGF0ZT4KPC9iaWJsaW9lbnRyeT4KCjxiaWJsaW9lbnRyeSBpZD0iY2l0OmJvb3N0OjpyZWYiPgo8YWJicmV2PnJlZjwvYWJicmV2Pgo8dGl0bGU+Qm9vc3QgcmVmPC90aXRsZT4KPGJpYmxpb21pc2M+PHVsaW5rIHVybD0iaHR0cDovL3d3dy5ib29zdC5vcmcvbGlicy9iaW5kL3JlZi5odG1sIj53d3cuYm9vc3Qub3JnL2xpYnMvYmluZC9yZWYuaHRtbDwvdWxpbms+CjwvYmlibGlvbWlzYz4KPHB1YmRhdGU+MjAwMjwvcHViZGF0ZT4KPC9iaWJsaW9lbnRyeT4KCjxiaWJsaW9lbnRyeSBpZD0iY2l0OmJvb3N0OjpiaW5kIj4KPGFiYnJldj5iaW5kPC9hYmJyZXY+Cjx0aXRsZT5Cb29zdCBCaW5kIExpYnJhcnk8L3RpdGxlPgo8YmlibGlvbWlzYz48dWxpbmsgdXJsPSJodHRwOi8vd3d3LmJvb3N0Lm9yZy9saWJzL2JpbmQvYmluZC5odG1sIj53d3cuYm9vc3Qub3JnL2xpYnMvYmluZC9iaW5kLmh0bWw8L3VsaW5rPgo8L2JpYmxpb21pc2M+CjxwdWJkYXRlPjIwMDI8L3B1YmRhdGU+CjwvYmlibGlvZW50cnk+Cgo8YmlibGlvZW50cnkgaWQ9ImNpdDpib29zdDo6ZnVuY3Rpb24iPgo8YWJicmV2PmZ1bmN0aW9uPC9hYmJyZXY+Cjx0aXRsZT5Cb29zdCBGdW5jdGlvbiBMaWJyYXJ5PC90aXRsZT4KPGJpYmxpb21pc2M+PHVsaW5rIHVybD0iaHR0cDovL3d3dy5ib29zdC5vcmcvbGlicy9mdW5jdGlvbi8iPnd3dy5ib29zdC5vcmcvbGlicy9mdW5jdGlvbi88L3VsaW5rPgo8L2JpYmxpb21pc2M+CjxwdWJkYXRlPjIwMDI8L3B1YmRhdGU+CjwvYmlibGlvZW50cnk+Cgo8YmlibGlvZW50cnkgaWQ9ImNpdDpmYysrIj4KPGFiYnJldj5mYysrPC9hYmJyZXY+Cjx0aXRsZT5UaGUgRkMrKyBsaWJyYXJ5OiBGdW5jdGlvbmFsIFByb2dyYW1taW5nIGluIEMrKzwvdGl0bGU+CjxhdXRob3I+CjxzdXJuYW1lPlNtYXJhZ2Rha2lzPC9zdXJuYW1lPgo8Zmlyc3RuYW1lPllhbm5pczwvZmlyc3RuYW1lPgo8L2F1dGhvcj4KPGF1dGhvcj4KPGZpcnN0bmFtZT5CcmlhbjwvZmlyc3RuYW1lPgo8c3VybmFtZT5NY05hbWFyYTwvc3VybmFtZT4KPC9hdXRob3I+CjxiaWJsaW9taXNjPjx1bGluayB1cmw9Imh0dHA6Ly93d3cuY2MuZ2F0ZWNoLmVkdS9+eWFubmlzL2ZjKysvIj53d3cuY2MuZ2F0ZWNoLmVkdS9+eWFubmlzL2ZjKysvPC91bGluaz4KPC9iaWJsaW9taXNjPgo8cHViZGF0ZT4yMDAyPC9wdWJkYXRlPgo8L2JpYmxpb2VudHJ5PgoKCjwvYmlibGlvZ3JhcGh5PgoKCjwvbGlicmFyeT4K