ICA8Y2hhcHRlciBpZD0iY29uZmlnLXdpbmUtbWFpbiI+CiAgICA8dGl0bGU+Q29uZmlndXJpbmcgV2luZTwvdGl0bGU+CiAgICA8cGFyYT4KICAgICAgTm93IHRoYXQgeW91IGhvcGVmdWxseSBtYW5hZ2VkIHRvIHN1Y2Nlc3NmdWxseSBpbnN0YWxsCiAgICAgIHRoZSBXaW5lIHByb2dyYW0gZmlsZXMsCiAgICAgIHRoaXMgY2hhcHRlciB3aWxsIHRlbGwgeW91IGhvdyB0byBjb25maWd1cmUgdGhlIFdpbmUgZW52aXJvbm1lbnQKICAgICAgcHJvcGVybHkgdG8gcnVuIHlvdXIgV2luZG93cyBwcm9ncmFtcy4KICAgIDwvcGFyYT4KICAgIDxwYXJhPgogICAgICBGaXJzdCwgd2UnbGwgZ2l2ZSB5b3UgYW4gb3ZlcnZpZXcgYWJvdXQgd2hpY2gga2luZHMgb2YKICAgICAgY29uZmlndXJhdGlvbiBhbmQgcHJvZ3JhbSBleGVjdXRpb24gYXNwZWN0cyBhIGZ1bGx5IGNvbmZpZ3VyZWQKICAgICAgV2luZG93cyBlbnZpcm9ubWVudCBoYXMgdG8gZnVsZmlsbCBpbiBvcmRlciB0byBlbnN1cmUgdGhhdCBtYW55CiAgICAgIFdpbmRvd3MgcHJvZ3JhbXMgcnVuIHN1Y2Nlc3NmdWxseSB3aXRob3V0IGVuY291bnRlcmluZyBhbnkKICAgICAgbWlzY29uZmlndXJlZCBvciBtaXNzaW5nIGl0ZW1zLgogICAgICBOZXh0LCB3ZSdsbCBzaG93IHlvdSB3aGljaCBlYXN5IGhlbHBlciBwcm9ncmFtcyBleGlzdAogICAgICB0byBlbmFibGUgZXZlbiBub3ZpY2UgdXNlcnMgdG8gY29tcGxldGUgdGhlIFdpbmUgZW52aXJvbm1lbnQKICAgICAgY29uZmlndXJhdGlvbiBpbiBhIGZhc3QgYW5kIGVhc3kgd2F5LgogICAgICBUaGUgbmV4dCBzZWN0aW9uIHdpbGwgZXhwbGFpbiB0aGUgcHVycG9zZSBvZiB0aGUgV2luZSBjb25maWd1cmF0aW9uIGZpbGUsCiAgICAgIGFuZCB3ZSdsbCBsaXN0IGFsbCBvZiBpdHMgc2V0dGluZ3MuCiAgICAgIEFmdGVyIHRoYXQsIHRoZSBuZXh0IHNlY3Rpb24gd2lsbCBkZXRhaWwgdGhlIG1vc3QgaW1wb3J0YW50IGFuZAogICAgICB1bmZvcnR1bmF0ZWx5IG1vc3QgZGlmZmljdWx0IGNvbmZpZ3VyYXRpb24gcGFydDoKICAgICAgaG93IHRvIGNvbmZpZ3VyZSB0aGUgZmlsZSBzeXN0ZW0gYW5kIERPUyBkcml2ZSBlbnZpcm9ubWVudCB0aGF0CiAgICAgIFdpbmRvd3MgcHJvZ3JhbXMgbmVlZC4KICAgICAgSW4gdGhlIGxhc3Qgc3RlcCB3ZSdsbCB0ZWxsIHlvdSBob3cgdG8gZXN0YWJsaXNoIGEgd29ya2luZyBXaW5kb3dzCiAgICAgIHJlZ2lzdHJ5IGJhc2UuCiAgICAgIEZpbmFsbHksIHRoZSByZW1haW5pbmcgcGFydHMgb2YgdGhpcyBjaGFwdGVyIGNvbnRhaW4gZGVzY3JpcHRpb25zCiAgICAgIG9mIHNwZWNpZmljIFdpbmUgY29uZmlndXJhdGlvbiBpdGVtcyB0aGF0IG1pZ2h0IGFsc28gYmUKICAgICAgb2YgaW50ZXJlc3QgdG8geW91LgogICAgPC9wYXJhPgoKICAgIDxzZWN0MSBpZD0iY29uZmlnLXJlcXVpcmVtZW50cy13aW5kb3dzIiB4cmVmbGFiZWw9Ii0tSW5zdGFsbGluZyBTZWN0aW9uLS0iPgogICAgICA8dGl0bGU+V2hhdCBhcmUgdGhlIHJlcXVpcmVtZW50cyBvZiBhIGZ1bGx5IHdvcmtpbmcgV2luZG93cyBlbnZpcm9ubWVudD88L3RpdGxlPgoKICAgICAgPHBhcmE+CiAgICAgICAgRm9ybWVybHkgYSBwYXJ0IG9mOiAiV1dOICM1MiBGZWF0dXJlOiBSZXBsYWNpbmcgV2luZG93cyIuCiAgICAgICAgV3JpdHRlbiBieSAmbmFtZS1vdmUta2FhdmVuOyA8ZW1haWw+JmVtYWlsLW92ZS1rYWF2ZW47PC9lbWFpbD4KICAgICAgPC9wYXJhPgoKICAgICAgICA8cGFyYT4KICAgICAgICAgIEEgV2luZG93cyBpbnN0YWxsYXRpb24gaXMgYSB2ZXJ5IGNvbXBsZXggc3RydWN0dXJlLiBJdCBjb25zaXN0cyBvZgoJICBtYW55IGRpZmZlcmVudCBwYXJ0cyB3aXRoIHZlcnkgZGlmZmVyZW50IGZ1bmN0aW9uYWxpdHkuCgkgIFdlJ2xsIHRyeSB0byBvdXRsaW5lIHRoZSBtb3N0IGltcG9ydGFudCBhc3BlY3RzIG9mIGl0LgogICAgICAgIDwvcGFyYT4KCiAgICAgICAgPGl0ZW1pemVkbGlzdD4KICAgICAgICAgIDxsaXN0aXRlbT4KICAgICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgICAgUmVnaXN0cnkuIE1hbnkga2V5cyBhcmUgc3VwcG9zZWQgdG8gZXhpc3QgYW5kIGNvbnRhaW4KICAgICAgICAgICAgICBtZWFuaW5nZnVsIGRhdGEsIGV2ZW4gaW4gYSBuZXdseS1pbnN0YWxsZWQgV2luZG93cy4KICAgICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPC9saXN0aXRlbT4KICAgICAgICAgIDxsaXN0aXRlbT4KICAgICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgICAgRGlyZWN0b3J5IHN0cnVjdHVyZS4gQXBwbGljYXRpb25zIGV4cGVjdCB0byBmaW5kIGFuZC9vcgogICAgICAgICAgICAgIGluc3RhbGwgdGhpbmdzIGluIHNwZWNpZmljIHByZWRldGVybWluZWQgbG9jYXRpb25zLiBNb3N0CiAgICAgICAgICAgICAgb2YgdGhlc2UgZGlyZWN0b3JpZXMgYXJlIGV4cGVjdGVkIHRvIGV4aXN0LiBCdXQgdW5saWtlCiAgICAgICAgICAgICAgVW5peCBkaXJlY3Rvcnkgc3RydWN0dXJlcywgbW9zdCBvZiB0aGVzZSBsb2NhdGlvbnMgYXJlCiAgICAgICAgICAgICAgbm90IGhhcmRjb2RlZCwgYW5kIGNhbiBiZSBxdWVyaWVkIHZpYSB0aGUgV2luZG93cyBBUEkKICAgICAgICAgICAgICBhbmQgdGhlIHJlZ2lzdHJ5LiBUaGlzIHBsYWNlcyBhZGRpdGlvbmFsIHJlcXVpcmVtZW50cyBvbgogICAgICAgICAgICAgIGEgV2luZSBpbnN0YWxsYXRpb24uCiAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgICAgICA8bGlzdGl0ZW0+CiAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgIFN5c3RlbSBETExzLiBJbiBXaW5kb3dzLCB0aGVzZSB1c3VhbGx5IHJlc2lkZSBpbiB0aGUKICAgICAgICAgICAgICA8ZmlsZW5hbWU+c3lzdGVtPC9maWxlbmFtZT4gKG9yCiAgICAgICAgICAgICAgPGZpbGVuYW1lPnN5c3RlbTMyPC9maWxlbmFtZT4pIGRpcmVjdG9yeS4gU29tZSBXaW5kb3dzCiAgICAgICAgICAgICAgcHJvZ3JhbXMgY2hlY2sgZm9yIHRoZWlyIGV4aXN0ZW5jZSBpbiB0aGVzZQogICAgICAgICAgICAgIGRpcmVjdG9yaWVzIGJlZm9yZSBhdHRlbXB0aW5nIHRvIGxvYWQgdGhlbS4gV2hpbGUgV2luZQogICAgICAgICAgICAgIGlzIGFibGUgdG8gbG9hZCBpdHMgb3duIGludGVybmFsIERMTHMKICAgICAgICAgICAgICAoPGZpbGVuYW1lPi5zbzwvZmlsZW5hbWU+IGZpbGVzKSB3aGVuIHRoZSBwcm9ncmFtCiAgICAgICAgICAgICAgYXNrcyBmb3IgYSBETEwsIFdpbmUgZG9lcyBub3Qgc2ltdWxhdGUgdGhlIGV4aXN0ZW5jZSBvZgogICAgICAgICAgICAgIG5vbmV4aXN0aW5nIGZpbGVzLgogICAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8L2xpc3RpdGVtPgogICAgICAgIDwvaXRlbWl6ZWRsaXN0PgoKICAgICAgICA8cGFyYT4KICAgICAgICAgIFdoaWxlIHRoZSB1c2VycyBhcmUgb2YgY291cnNlIGZyZWUgdG8gc2V0IHVwIGV2ZXJ5dGhpbmcKICAgICAgICAgIHRoZW1zZWx2ZXMsIHRoZSBXaW5lIHRlYW0gd2lsbCBtYWtlIHRoZSBhdXRvbWF0ZWQgV2luZSBzb3VyY2UKICAgICAgICAgIGluc3RhbGxhdGlvbiBzY3JpcHQsIDxmaWxlbmFtZT50b29scy93aW5laW5zdGFsbDwvZmlsZW5hbWU+LAogICAgICAgICAgZG8gZXZlcnl0aGluZyB3ZSBmaW5kIG5lY2Vzc2FyeSB0byBkbzsgcnVubmluZyB0aGUKICAgICAgICAgIGNvbnZlbnRpb25hbCA8dXNlcmlucHV0PmNvbmZpZ3VyZSAmJiBtYWtlIGRlcGVuZCAmJiBtYWtlICYmIG1ha2UKICAgICAgICAgICAgaW5zdGFsbDwvdXNlcmlucHV0PiBjeWNsZSBpcyB0aHVzIG5vdCByZWNvbW1lbmRlZCwgdW5sZXNzCiAgICAgICAgICB5b3Uga25vdyB3aGF0IHlvdSdyZSBkb2luZy4gQXQgdGhlIG1vbWVudCwKICAgICAgICAgIDxmaWxlbmFtZT50b29scy93aW5laW5zdGFsbDwvZmlsZW5hbWU+IGlzIGFibGUgdG8gY3JlYXRlIGEKICAgICAgICAgIGNvbmZpZ3VyYXRpb24gZmlsZSwgaW5zdGFsbCB0aGUgcmVnaXN0cnksIGFuZCBjcmVhdGUgdGhlCiAgICAgICAgICBkaXJlY3Rvcnkgc3RydWN0dXJlIGl0c2VsZi4KICAgICAgICA8L3BhcmE+CgogICAgPC9zZWN0MT4KCiAgICA8c2VjdDEgaWQ9ImNvbmZpZy1oZWxwZXItcHJvZ3JhbXMiPgogICAgICA8dGl0bGU+RWFzeSBjb25maWd1cmF0aW9uIGhlbHBlciBwcm9ncmFtczwvdGl0bGU+CgogICAgICA8cGFyYT4KICAgICAgICBNYW5hZ2luZyB0aGUgV2luZSBjb25maWd1cmF0aW9uIGZpbGUgc2V0dGluZ3MgY2FuIGJlIGEKCWRpZmZpY3VsdCB0YXNrLCBzb21ldGltZXMgdG9vIGRpZmZpY3VsdCBmb3Igc29tZSBwZW9wbGUuCglUaGF0J3Mgd2h5IHRoZXJlIGFyZSBzb21lIGhlbHBlciBhcHBsaWNhdGlvbnMgZm9yIGVhc2lseSBzZXR0aW5nIHVwIGFuCglpbml0aWFsIHdpbmUgY29uZmlndXJhdGlvbiBmaWxlIHdpdGggdXNlZnVsIGRlZmF1bHQgc2V0dGluZ3MuCiAgICAgIDwvcGFyYT4KCiAgICAgIDxzZWN0MiBpZD0iY29uZmlnLWhlbHBlci13aW5lc2V0dXB0ayI+CiAgICAgICAgPHRpdGxlPldpbmVTZXR1cFRrPC90aXRsZT4KCTxwYXJhPgoJICBXaW5lU2V0dXBUayBpcyBhIGdyYXBoaWNhbCBXaW5lIGNvbmZpZ3VyYXRpb24gdG9vbCB3aXRoCgkgIGluY3JlZGlibHkgZWFzeSBoYW5kbGluZyBvZiBXaW5lIGNvbmZpZ3VyYXRpb24gaXNzdWVzLCB0byBiZQoJICB1c2VkIGZvciBjb25maWd1cmluZyB0aGUgV2luZSBlbnZpcm9ubWVudCBhZnRlciBoYXZpbmcKCSAgaW5zdGFsbGVkIHRoZSBXaW5lIGZpbGVzLgoJICBJdCBoYXMgYmVlbiB3cml0dGVuIGJ5IENvZGVXZWF2ZXJzIGluIDIwMDAgYXMgcGFydCBvZiBhIGhvc3QKCSAgb2Ygb3RoZXIgZWZmb3J0cyB0byBtYWtlIFdpbmUgbW9yZSBkZXNrdG9wIG9yaWVudGVkLgoJPC9wYXJhPgoJPHBhcmE+CgkgIElmIHlvdSdyZSB1c2luZyBEZWJpYW4sIHNpbXBseSBpbnN0YWxsIHRoZSB3aW5lc2V0dXB0awoJICBwYWNrYWdlIChhcyByb290KToKCTwvcGFyYT4KICAgICAgICA8c2NyZWVuPgogIDxwcm9tcHQ+IyA8L3Byb21wdD48dXNlcmlucHV0PmFwdC1nZXQgaW5zdGFsbCB3aW5lc2V0dXB0azwvdXNlcmlucHV0PgogICAgICAgIDwvc2NyZWVuPgoJPHBhcmE+CgkgIElmIHlvdSdyZSB1c2luZyBhbm90aGVyIGRpc3RyaWJ1dGlvbiwgc2VhcmNoIGZvciB0aGUgcGFja2FnZSBvbgoJICB0aGUgbmV0LgoJPC9wYXJhPgogICAgICA8L3NlY3QyPgogICAgICAKICAgICAgPHNlY3QyIGlkPSJjb25maWctaGVscGVyLXdpbmVpbnN0YWxsIj4KICAgICAgICA8dGl0bGU+d2luZWluc3RhbGw8L3RpdGxlPgoJPHBhcmE+CgkgIDxjb21tYW5kPndpbmVpbnN0YWxsPC9jb21tYW5kPiBpcyBhIHNtYWxsIGNvbmZpZ3VyYXRpb24gdG9vbAoJICByZXNpZGluZyBhcyA8ZmlsZW5hbWU+dG9vbHMvd2luZWluc3RhbGw8L2ZpbGVuYW1lPiBpbiBhIFdpbmUKCSAgc291cmNlIGNvZGUgdHJlZS4gIEl0IGhhcyBiZWVuIHdyaXR0ZW4gdG8gYWxsb3cgZm9yIGFuIGVhc3kKCSAgYW5kIGNvbXBsZXRlIGNvbXBpbGF0aW9uL2luc3RhbGxhdGlvbiBvZiBXaW5lIHNvdXJjZSBjb2RlIGZvcgoJICBwZW9wbGUgd2hvIGRvbid0IGJvdGhlciB3aXRoIHJlYWRpbmcgaGVhcHMgb2YgdmVyeSB2YWx1YWJsZQoJICBhbmQgaW5mb3JtYXRpdmUgZG9jdW1lbnRhdGlvbiA7LSkKCTwvcGFyYT4KCTxwYXJhPgoJICBPbmNlIHlvdSBoYXZlIHN1Y2Nlc3NmdWxseSBleHRyYWN0ZWQgdGhlIFdpbmUgc291cmNlIGNvZGUKCSAgdHJlZSwgY2hhbmdlIHRvIHRoZSBtYWluIGRpcmVjdG9yeSBvZiBpdCBhbmQgdGhlbiBydW4gKGFzCgkgIHVzZXIpOgoJPC9wYXJhPgogICAgICAgIDxzY3JlZW4+CiAgPHByb21wdD4kIDwvcHJvbXB0Pjx1c2VyaW5wdXQ+Li90b29scy93aW5laW5zdGFsbDwvdXNlcmlucHV0PgogICAgICAgIDwvc2NyZWVuPgoJPHBhcmE+CgkgIERvaW5nIHNvIHdpbGwgY29tcGlsZSBXaW5lLCBpbnN0YWxsIFdpbmUgYW5kIGNvbmZpZ3VyZSB0aGUKCSAgV2luZSBlbnZpcm9ubWVudCAoZWl0aGVyIGJ5IHByb3ZpZGluZyBhY2Nlc3MgdG8gYSBXaW5kb3dzCgkgIHBhcnRpdGlvbiBvciBieSBjcmVhdGluZyBhIHByb3Blcmx5IGNvbmZpZ3VyZWQgbm8td2luZG93cwoJICBkaXJlY3RvcnkgZW52aXJvbm1lbnQpLgoJPC9wYXJhPgogICAgICA8L3NlY3QyPgoKICAgICAgPHNlY3QyIGlkPSJjb25maWctaGVscGVyLXdpbmVjZmciPgogICAgICAgIDx0aXRsZT53aW5lY2ZnPC90aXRsZT4KCTxwYXJhPgoJICA8Y29tbWFuZD53aW5lY2ZnPC9jb21tYW5kPiBpcyBhIHNtYWxsIGdyYXBoaWNhbCBjb25maWd1cmF0aW9uIHRvb2wKCSAgcmVzaWRpbmcgYXMgPGZpbGVuYW1lPnByb2dyYW1zL3dpbmVjZmc8L2ZpbGVuYW1lPiBpbiBhIFdpbmUKCSAgc291cmNlIGNvZGUgdHJlZS4gSXQgaXMgYSBXaW5lbGliIGFwcCBtYWtpbmcgdXNlIG9mIHN0YW5kYXJkCgkgIFdpbjMyIEdVSSBjb250cm9scyB0byBlYXNpbHkgY3VzdG9taXplIGVudHJpZXMgaW4gYSBXaW5lCgkgIGNvbmZpZ3VyYXRpb24gZmlsZS4KCTwvcGFyYT4KICAgICAgPC9zZWN0Mj4KICAgIDwvc2VjdDE+CgogICAgPHNlY3QxIGlkPSJjb25maWctdmVyaWZ5Ij4KICAgICAgPHRpdGxlPlZlcmlmaWNhdGlvbiBvZiBjb3JyZWN0IGNvbmZpZ3VyYXRpb248L3RpdGxlPgoKICAgICAgPHBhcmE+CglBZnRlciB5b3UgZmluaXNoZWQgY29uZmlndXJpbmcgV2luZSwgeW91IG1heSBydW4gYSBQZXJsCglzY3JpcHQgY2FsbGVkIDxjb21tYW5kPndpbmVjaGVjazwvY29tbWFuZD4sIHRvIGJlIGZvdW5kCglpbiBXaW5lJ3MgdG9vbHMvIGRpcmVjdG9yeS4gSXQgdHJpZXMgdG8gY2hlY2sgeW91cgoJY29uZmlndXJhdGlvbidzIGNvcnJlY3RuZXNzIGJ5IGNoZWNraW5nIGZvciBzb21lIHBvcHVsYXIKCXByb2JsZW1zLgoKCVRoZSBsYXRlc3QgdmVyc2lvbiBjYW4gYWx3YXlzIGJlIGZvdW5kIGF0Cgk8dWxpbmsgdXJsPSJodHRwOi8vaG9tZS5hcmNvci5kZS9hbmRpLm1vaHIvZG93bmxvYWQvd2luZWNoZWNrIj5odHRwOi8vaG9tZS5hcmNvci5kZS9hbmRpLm1vaHIvZG93bmxvYWQvd2luZWNoZWNrPC91bGluaz4uCgogICAgICAgIFRvIHJ1biBpdCwgcnVuIGluIGEgPGdsb3NzdGVybT50ZXJtaW5hbDwvZ2xvc3N0ZXJtPiBpbiB0aGUgV2luZSBzb3VyY2UgdHJlZSBkaXJlY3Rvcnk6CiAgICAgIDwvcGFyYT4KICAgICAgPHNjcmVlbj4KICA8cHJvbXB0PiQgPC8+PHVzZXJpbnB1dD5jZCB0b29sczwvPgogIDxwcm9tcHQ+JCA8Lz48dXNlcmlucHV0PnBlcmwgLi93aW5lY2hlY2s8Lz4KICAgICAgPC9zY3JlZW4+CiAgICAgIDxwYXJhPgoJVGhlIHdpbmVjaGVjayBvdXRwdXQgd2lsbCBiZSBhIHBlcmNlbnRhZ2Ugc2NvcmUgaW5kaWNhdGluZyBXaW5lCgljb25maWd1cmF0aW9uIGNvcnJlY3RuZXNzLgoJTm90ZSB0aGF0IHdpbmVjaGVjayBpcyBvbmx5IGFscGhhLCBzbyBpdCdzIG5vdCB2ZXJ5IGNvbXBsZXRlIG9yCgkxMDAlIGFjY3VyYXRlLgogICAgICA8L3BhcmE+CgogICAgICA8cGFyYT4KICAgICAgICBJZiB0aGlzIHlpZWxkcyBhICJnb29kIiBwZXJjZW50YWdlIHNjb3JlLCB0aGVuIHlvdSBjYW4gY29uc2lkZXIKCXlvdXIgV2luZSBpbnN0YWxsYXRpb24gdG8gYmUgZmluaXNoZWQgc3VjY2Vzc2Z1bGx5OgoJQ29uZ3JhdHVsYXRpb25zIQoJT3RoZXJ3aXNlIChvciBpZiB0aGVyZSBhcmUgc3RpbGwgc29tZSBjb25maWd1cmF0aW9uIHByb2JsZW1zCgl0aGF0IDxjb21tYW5kPndpbmVjaGVjazwvY29tbWFuZD4gZG9lc24ndCBjYXRjaCBwcm9wZXJseSksIHBsZWFzZSBjaGVjayBvdXQgdGhlCgljb25maWd1cmF0aW9uIGRvY3VtZW50YXRpb24gYmVsb3cgdG8gZmluZCBvdXQgbW9yZSBhYm91dCBzb21lCglwYXJ0cywgb3IgcHJvY2VlZCB0byB0aGUgPGxpbmsgbGlua2VuZD0iYnVncyI+VHJvdWJsZXNob290aW5nCgljaGFwdGVyPC9saW5rPi4KICAgICAgPC9wYXJhPgogICAgPC9zZWN0MT4KCiAgICA8c2VjdDEgaWQ9ImNvbmZpZy1maWxlIj4KICAgICAgPHRpdGxlPlRoZSBXaW5lIENvbmZpZ3VyYXRpb24gRmlsZTwvdGl0bGU+CiAgICAgIDxwYXJhPgogICAgICAgIFRoaXMgc2VjdGlvbiBpcyBtZWFudCB0byBjb250YWluIGJvdGggYW4gZWFzeSBzdGVwLWJ5LXN0ZXAgaW50cm9kdWN0aW9uCgl0byB0aGUgV2luZSBjb25maWd1cmF0aW9uIGZpbGUgKGZvciBuZXcgV2luZSB1c2VycykKCWFuZCBhIGNvbXBsZXRlIHJlZmVyZW5jZSB0byBhbGwgV2luZSBjb25maWd1cmF0aW9uIGZpbGUgc2V0dGluZ3MgKGZvcgoJYWR2YW5jZWQgdXNlcnMpLgogICAgICA8L3BhcmE+CiAgICAgIDxwYXJhPgogICAgICAgIFBhcnRzIHRha2VuIGZyb20gdGhlIGZvcm1lciBmaWxlIDxmaWxlbmFtZT53aW5lL2RvY3VtZW50YXRpb24vY29uZmlnPC9maWxlbmFtZT4sCiAgICAgICAgQ29weXJpZ2h0IDE5OTkgJm5hbWUtYWRhbS1zYWNhcm55OyA8ZW1haWw+JmVtYWlsLWFkYW0tc2FjYXJueTs8L2VtYWlsPgogICAgICA8L3BhcmE+CgogICAgICA8c2VjdDI+CiAgICAgICAgPHRpdGxlPkNvbmZpZ3VyYXRpb24gRmlsZSBJbnRyb2R1Y3Rpb248L3RpdGxlPgogICAgICAgIDxwYXJhPgogICAgICAgICAgVGhlIFdpbmUgY29uZmlndXJhdGlvbiBmaWxlIGlzIHRoZSBjZW50cmFsIGZpbGUgdG8gc3RvcmUKCSAgY29uZmlndXJhdGlvbiBzZXR0aW5ncyBmb3IgV2luZS4KCSAgVGhpcyBmaWxlICh3aGljaCBpcyBjYWxsZWQgPGZpbGVuYW1lPmNvbmZpZzwvZmlsZW5hbWU+KQoJICBjYW4gYmUgZm91bmQgaW4gdGhlIHN1YiBkaXJlY3RvcnkgPGZpbGVuYW1lPi53aW5lLzwvZmlsZW5hbWU+CgkgIG9mIHlvdXIgdXNlcidzIGhvbWUgZGlyZWN0b3J5CgkgIChkaXJlY3RvcnkgPGZpbGVuYW1lPi9ob21lL3VzZXIvPC9maWxlbmFtZT4pLiBJbiBvdGhlciB3b3JkcywgdGhlIFdpbmUKCSAgY29uZmlndXJhdGlvbiBmaWxlIGlzIDxmaWxlbmFtZT5+Ly53aW5lL2NvbmZpZzwvZmlsZW5hbWU+LgoJICBOb3RlIHRoYXQgc2luY2UgdGhlIFdpbmUgY29uZmlndXJhdGlvbiBmaWxlIGlzIGEgcGFydCBvZiB0aGUKCSAgV2luZSByZWdpc3RyeSBmaWxlIHN5c3RlbSwgdGhpcyBmaWxlIGFsc28KCSAgPGVtcGhhc2lzPnJlcXVpcmVzPC9lbXBoYXNpcz4gYSBjb3JyZWN0ICJXSU5FIFJFR0lTVFJZCgkgIFZlcnNpb24gMiIgaGVhZGVyIGxpbmUgdG8gYmUgcmVjb2duaXplZCBwcm9wZXJseSwganVzdCBsaWtlCgkgIGFsbCBvdGhlciBXaW5lIHJlZ2lzdHJ5IHRleHQgZmlsZXMgKGp1c3QgaW4gY2FzZSB5b3UgZGVjaWRlZAoJICB0byB3cml0ZSB5b3VyIG93biByZWdpc3RyeSBmaWxlIGZyb20gc2NyYXRjaCBhbmQgd29uZGVyIHdoeQoJICBXaW5lIGtlZXBzIHJlamVjdGluZyBpdCkuCiAgICAgICAgPC9wYXJhPgogICAgICAgIDxwYXJhPgogICAgICAgICAgVGhlIHNldHRpbmdzIGF2YWlsYWJsZSBpbiB0aGUgY29uZmlndXJhdGlvbiBmaWxlIGluY2x1ZGU6CiAgICAgICAgICA8aXRlbWl6ZWRsaXN0PgogICAgICAgICAgICA8bGlzdGl0ZW0+CiAgICAgICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgICAgICBEcml2ZXMgYW5kIGluZm9ybWF0aW9uIGFib3V0IHRoZW0KICAgICAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgICAgICAgIDxsaXN0aXRlbT4KICAgICAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgICAgIERpcmVjdG9yeSBzZXR0aW5ncwogICAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgICAgPC9saXN0aXRlbT4KICAgICAgICAgICAgPGxpc3RpdGVtPgogICAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgICAgUG9ydCBzZXR0aW5ncwogICAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgICAgPC9saXN0aXRlbT4KICAgICAgICAgICAgPGxpc3RpdGVtPgogICAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgICAgVGhlIFdpbmUgbG9vayBhbmQgZmVlbAogICAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgICAgPC9saXN0aXRlbT4KICAgICAgICAgICAgPGxpc3RpdGVtPgogICAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgICAgV2luZSdzIERMTCB1c2FnZQogICAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgICAgPC9saXN0aXRlbT4KICAgICAgICAgICAgPGxpc3RpdGVtPgogICAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgICAgV2luZSdzIG11bHRpbWVkaWEgZHJpdmVycyBhbmQgRExMIGNvbmZpZ3VyYXRpb24KICAgICAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgICAgICA8L2l0ZW1pemVkbGlzdD4KICAgICAgICA8L3BhcmE+CiAgICAgIDwvc2VjdDI+CgogICAgICA8c2VjdDI+CiAgICAgICAgPHRpdGxlPkNyZWF0aW5nIE9yIE1vZGlmeWluZyBUaGUgQ29uZmlndXJhdGlvbiBGaWxlPC90aXRsZT4KICAgICAgICA8cGFyYT4KCSAgSWYgeW91IGp1c3QgaW5zdGFsbGVkIFdpbmUgZm9yIHRoZSBmaXJzdCB0aW1lIGFuZCB3YW50IHRvCgkgIGZpbmlzaCBXaW5lIGluc3RhbGxhdGlvbiBieSBjb25maWd1cmluZyBpdCBub3csIHRoZW4geW91IGNvdWxkCgkgIHVzZSBvdXIgc2FtcGxlIGNvbmZpZ3VyYXRpb24gZmlsZSA8ZmlsZW5hbWU+Y29uZmlnPC9maWxlbmFtZT4KCSAgKHdoaWNoIGNhbiBiZSBmb3VuZCBpbiB0aGUgZGlyZWN0b3J5CgkgIDxmaWxlbmFtZT5kb2N1bWVudGF0aW9uL3NhbXBsZXMvPC9maWxlbmFtZT4gb2YgdGhlIFdpbmUgc291cmNlCgkgIGNvZGUgZGlyZWN0b3J5KSBhcyBhIGJhc2UgZm9yIGFkYXB0aW5nIHRoZSBXaW5lIGNvbmZpZ3VyYXRpb24KCSAgZmlsZSB0byB0aGUgc2V0dGluZ3MgeW91IHdhbnQuCgkgIEZpcnN0LCBJIHNob3VsZCBtZW50aW9uIHRoYXQgeW91IHNob3VsZCBub3QgZm9yZ2V0IHRvIG1ha2UKCSAgc3VyZSB0aGF0IGFueSBwcmV2aW91cyBjb25maWd1cmF0aW9uIGZpbGUgYXQKCSAgPGZpbGVuYW1lPn4vLndpbmUvY29uZmlnPC9maWxlbmFtZT4gaGFzIGJlZW4gc2FmZWx5IG1vdmVkIG91dAoJICBvZiB0aGUgd2F5IGluc3RlYWQgb2Ygc2ltcGx5IG92ZXJ3cml0aW5nIGl0IHdoZW4geW91IHdpbGwgbm93CgkgIGNvcHkgb3ZlciB0aGUgc2FtcGxlIGNvbmZpZ3VyYXRpb24gZmlsZS4KICAgICAgICA8L3BhcmE+Cgk8cGFyYT4KCSAgSWYgeW91IGRvbid0IGhhdmUgYSBwcmUtZXhpc3RpbmcgY29uZmlndXJhdGlvbiBmaWxlIGFuZCB0aHVzCgkgIG5lZWQgdG8gY29weSBvdmVyIG91ciBzYW1wbGUgY29uZmlndXJhdGlvbiBmaWxlIHRvIHRoZQoJICBzdGFuZGFyZCBXaW5lIGNvbmZpZ3VyYXRpb24gZmlsZSBsb2NhdGlvbiwgZG8gaW4gYQoJICA8Z2xvc3N0ZXJtPnRlcm1pbmFsPC9nbG9zc3Rlcm0+OgogICAgICAgICAgPHNjcmVlbj4KICA8cHJvbXB0PiQgPC8+PHVzZXJpbnB1dD5ta2RpciB+Ly53aW5lLzwvPgogIDxwcm9tcHQ+JCA8Lz48dXNlcmlucHV0PmNwIDxyZXBsYWNlYWJsZT5kaXJfdG9fd2luZV9zb3VyY2VfY29kZTwvcmVwbGFjZWFibGU+L2RvY3VtZW50YXRpb24vc2FtcGxlcy9jb25maWcgfi8ud2luZS9jb25maWc8Lz4KICAgICAgICAgIDwvc2NyZWVuPgoJICBPdGhlcndpc2UsIHNpbXBseSB1c2UgdGhlIGFscmVhZHkgZXhpc3RpbmcgY29uZmlndXJhdGlvbiBmaWxlCgkgIGF0IDxmaWxlbmFtZT5+Ly53aW5lL2NvbmZpZzwvZmlsZW5hbWU+LgoJPC9wYXJhPgoJPHBhcmE+CgkgIE5vdyB5b3UgY2FuIHN0YXJ0IGFkYXB0aW5nIHRoZSBjb25maWd1cmF0aW9uIGZpbGUncyBzZXR0aW5ncyB3aXRoIGFuCgkgIDxnbG9zc3Rlcm0+ZWRpdG9yPC9nbG9zc3Rlcm0+IGFjY29yZGluZyB0byB0aGUgZG9jdW1lbnRhdGlvbgoJICBiZWxvdy4KCSAgTm90ZSB0aGF0IHlvdSBzaG91bGQgPGVtcGhhc2lzPm9ubHk8L2VtcGhhc2lzPiBjaGFuZ2UKCSAgY29uZmlndXJhdGlvbiBmaWxlIHNldHRpbmdzIGlmIHdpbmVzZXJ2ZXIgaXMgbm90IHJ1bm5pbmcgKGluCgkgIG90aGVyIHdvcmRzOiBpZiB5b3VyIHVzZXIgZG9lc24ndCBoYXZlIGEgV2luZSBzZXNzaW9uIHJ1bm5pbmcpLAoJICBvdGhlcndpc2UgV2luZSB3b24ndCB1c2UgdGhlbSAtIGFuZCBldmVuIHdvcnNlLCB3aW5lc2VydmVyIHdpbGwKCSAgb3ZlcndyaXRlIHRoZW0gd2l0aCB0aGUgb2xkIHNldHRpbmdzIG9uY2Ugd2luZXNlcnZlciBxdWl0cyEhCgk8L3BhcmE+CiAgICAgIDwvc2VjdDI+CgogICAgICA8c2VjdDIgaWQ9ImNvbmZpZy1maWxlLWhvdyI+CiAgICAgICAgPHRpdGxlPldoYXQgRG9lcyBJdCBDb250YWluPzwvdGl0bGU+CgogICAgICAgIDxwYXJhPgoJICBMZXQncyBzdGFydCBieSBnaXZpbmcgYW4gb3ZlcnZpZXcgb2Ygd2hpY2ggc2VjdGlvbnMgYQoJICBjb25maWd1cmF0aW9uIGZpbGUgbWF5IGNvbnRhaW4sIGFuZCB3aGV0aGVyIHRoZSBpbmNsdXNpb24gb2YKCSAgdGhlIHJlc3BlY3RpdmUgc2VjdGlvbiBpcyA8ZW1waGFzaXM+bmVlZGVkPC9lbXBoYXNpcz4gb3Igb25seSA8ZW1waGFzaXM+cmVjb21tZW5kZWQ8L2VtcGhhc2lzPiAoInJlY21kIikuCgk8L3BhcmE+CgogICAgICAgIDxpbmZvcm1hbHRhYmxlIGZyYW1lPSJhbGwiPgogICAgICAgICAgPHRncm91cCBjb2xzPSIzIj4KICAgICAgICAgICAgPHRoZWFkPgogICAgICAgICAgICAgIDxyb3c+CiAgICAgICAgICAgICAgICA8ZW50cnk+U2VjdGlvbiBOYW1lPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5OZWVkZWQ/PC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5XaGF0IGl0IERvZXM8L2VudHJ5PgogICAgICAgICAgICAgIDwvcm93PgogICAgICAgICAgICA8L3RoZWFkPgogICAgICAgICAgICA8dGJvZHk+CiAgICAgICAgICAgICAgPHJvdz4KICAgICAgICAgICAgICAgIDxlbnRyeT5bRHJpdmUgeF08L2VudHJ5PgogICAgICAgICAgICAgICAgPGVudHJ5PnllczwvZW50cnk+CiAgICAgICAgICAgICAgICA8ZW50cnk+U2V0cyB1cCBkcml2ZSBtYXBwaW5ncyB0byBiZSB1c2VkIGJ5IFdpbmU8L2VudHJ5PgogICAgICAgICAgICAgIDwvcm93PgogICAgICAgICAgICAgIDxyb3c+CiAgICAgICAgICAgICAgICA8ZW50cnk+W3dpbmVdPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT55ZXM8L2VudHJ5PgogICAgICAgICAgICAgICAgPGVudHJ5PkdlbmVyYWwgc2V0dGluZ3MgZm9yIFdpbmU8L2VudHJ5PgogICAgICAgICAgICAgIDwvcm93PgogICAgICAgICAgICAgIDxyb3c+CiAgICAgICAgICAgICAgICA8ZW50cnk+W0RsbERlZmF1bHRzXTwvZW50cnk+CiAgICAgICAgICAgICAgICA8ZW50cnk+cmVjbWQ8L2VudHJ5PgogICAgICAgICAgICAgICAgPGVudHJ5PkRlZmF1bHRzIGZvciBsb2FkaW5nIERMTCdzPC9lbnRyeT4KICAgICAgICAgICAgICA8L3Jvdz4KICAgICAgICAgICAgICA8cm93PgogICAgICAgICAgICAgICAgPGVudHJ5PltEbGxQYWlyc108L2VudHJ5PgogICAgICAgICAgICAgICAgPGVudHJ5PnJlY21kPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5TYW5pdHkgY2hlY2tlcnMgZm9yIERMTCdzPC9lbnRyeT4KICAgICAgICAgICAgICA8L3Jvdz4KICAgICAgICAgICAgICA8cm93PgogICAgICAgICAgICAgICAgPGVudHJ5PltEbGxPdmVycmlkZXNdPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5yZWNtZDwvZW50cnk+CiAgICAgICAgICAgICAgICA8ZW50cnk+T3ZlcnJpZGVzIGRlZmF1bHRzIGZvciBETEwgbG9hZGluZzwvZW50cnk+CiAgICAgICAgICAgICAgPC9yb3c+CiAgICAgICAgICAgICAgPHJvdz4KICAgICAgICAgICAgICAgIDxlbnRyeT5beDExZHJ2XTwvZW50cnk+CiAgICAgICAgICAgICAgICA8ZW50cnk+cmVjbWQ8L2VudHJ5PgogICAgICAgICAgICAgICAgPGVudHJ5PkdyYXBoaWNzIGRyaXZlciBzZXR0aW5nczwvZW50cnk+CiAgICAgICAgICAgICAgPC9yb3c+CiAgICAgICAgICAgICAgPHJvdz4KICAgICAgICAgICAgICAgIDxlbnRyeT5bZm9udHNdPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT55ZXM8L2VudHJ5PgogICAgICAgICAgICAgICAgPGVudHJ5PkZvbnQgYXBwZWFyYW5jZSBhbmQgcmVjb2duaXRpb248L2VudHJ5PgogICAgICAgICAgICAgIDwvcm93PgogICAgICAgICAgICAgIDxyb3c+CiAgICAgICAgICAgICAgICA8ZW50cnk+W3NlcmlhbHBvcnRzXTwvZW50cnk+CiAgICAgICAgICAgICAgICA8ZW50cnk+bm88L2VudHJ5PgogICAgICAgICAgICAgICAgPGVudHJ5PkNPTSBwb3J0cyBzZWVuIGJ5IFdpbmU8L2VudHJ5PgogICAgICAgICAgICAgIDwvcm93PgogICAgICAgICAgICAgIDxyb3c+CiAgICAgICAgICAgICAgICA8ZW50cnk+W3BhcmFsbGVscG9ydHNdPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5ubzwvZW50cnk+CiAgICAgICAgICAgICAgICA8ZW50cnk+TFBUIHBvcnRzIHNlZW4gYnkgV2luZTwvZW50cnk+CiAgICAgICAgICAgICAgPC9yb3c+CiAgICAgICAgICAgICAgPHJvdz4KICAgICAgICAgICAgICAgIDxlbnRyeT5bcHBkZXZdPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5ubzwvZW50cnk+CiAgICAgICAgICAgICAgICA8ZW50cnk+UGFyYWxsZWxwb3J0IGVtdWxhdGlvbjwvZW50cnk+CiAgICAgICAgICAgICAgPC9yb3c+CiAgICAgICAgICAgICAgPHJvdz4KICAgICAgICAgICAgICAgIDxlbnRyeT5bc3Bvb2xlcl08L2VudHJ5PgogICAgICAgICAgICAgICAgPGVudHJ5Pm5vPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5QcmludCBzcG9vbGluZzwvZW50cnk+CiAgICAgICAgICAgICAgPC9yb3c+CiAgICAgICAgICAgICAgPHJvdz4KICAgICAgICAgICAgICAgIDxlbnRyeT5bcG9ydHNdPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5ubzwvZW50cnk+CiAgICAgICAgICAgICAgICA8ZW50cnk+RGlyZWN0IHBvcnQgYWNjZXNzPC9lbnRyeT4KICAgICAgICAgICAgICA8L3Jvdz4KICAgICAgICAgICAgICA8cm93PgogICAgICAgICAgICAgICAgPGVudHJ5PltEZWJ1Z108L2VudHJ5PgogICAgICAgICAgICAgICAgPGVudHJ5Pm5vPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5XaGF0IHRvIGRvIHdpdGggY2VydGFpbiBkZWJ1ZyBtZXNzYWdlczwvZW50cnk+CiAgICAgICAgICAgICAgPC9yb3c+CiAgICAgICAgICAgICAgPHJvdz4KICAgICAgICAgICAgICAgIDxlbnRyeT5bUmVnaXN0cnldPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5ubzwvZW50cnk+CiAgICAgICAgICAgICAgICA8ZW50cnk+U3BlY2lmaWVzIGxvY2F0aW9ucyBvZiB3aW5kb3dzIHJlZ2lzdHJ5IGZpbGVzPC9lbnRyeT4KICAgICAgICAgICAgICA8L3Jvdz4KICAgICAgICAgICAgICA8cm93PgogICAgICAgICAgICAgICAgPGVudHJ5Plt0d2Vhay5sYXlvdXRdPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5yZWNtZDwvZW50cnk+CiAgICAgICAgICAgICAgICA8ZW50cnk+QXBwZWFyYW5jZSBvZiBXaW5lPC9lbnRyeT4KICAgICAgICAgICAgICA8L3Jvdz4KICAgICAgICAgICAgICA8cm93PgogICAgICAgICAgICAgICAgPGVudHJ5Pltwcm9ncmFtc108L2VudHJ5PgogICAgICAgICAgICAgICAgPGVudHJ5Pm5vPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5Qcm9ncmFtcyB0byBiZSBydW4gYXV0b21hdGljYWxseTwvZW50cnk+CiAgICAgICAgICAgICAgPC9yb3c+CiAgICAgICAgICAgICAgPHJvdz4KICAgICAgICAgICAgICAgIDxlbnRyeT5bQ29uc29sZV08L2VudHJ5PgogICAgICAgICAgICAgICAgPGVudHJ5Pm5vPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5Db25zb2xlIHNldHRpbmdzPC9lbnRyeT4KICAgICAgICAgICAgICA8L3Jvdz4KICAgICAgICAgICAgICA8cm93PgogICAgICAgICAgICAgICAgPGVudHJ5PltDbGlwYm9hcmRdPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5ubzwvZW50cnk+CiAgICAgICAgICAgICAgICA8ZW50cnk+SW50ZXJhY3Rpb24gZm9yIFdpbmUgYW5kIFgxMSBjbGlwYm9hcmQ8L2VudHJ5PgogICAgICAgICAgICAgIDwvcm93PgogICAgICAgICAgICAgIDxyb3c+CiAgICAgICAgICAgICAgICA8ZW50cnk+W2FmbWRpcnNdPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5ubzwvZW50cnk+CiAgICAgICAgICAgICAgICA8ZW50cnk+UG9zdHNjcmlwdCBkcml2ZXIgc2V0dGluZ3M8L2VudHJ5PgogICAgICAgICAgICAgIDwvcm93PgogICAgICAgICAgICAgIDxyb3c+CiAgICAgICAgICAgICAgICA8ZW50cnk+W1dpbk1NXTwvZW50cnk+CiAgICAgICAgICAgICAgICA8ZW50cnk+eWVzPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5NdWx0aW1lZGlhIHNldHRpbmdzPC9lbnRyeT4KICAgICAgICAgICAgICA8L3Jvdz4KICAgICAgICAgICAgICA8cm93PgogICAgICAgICAgICAgICAgPGVudHJ5PltBcHBEZWZhdWx0c108L2VudHJ5PgogICAgICAgICAgICAgICAgPGVudHJ5Pm5vPC9lbnRyeT4KICAgICAgICAgICAgICAgIDxlbnRyeT5PdmVyd3JpdGUgdGhlIHNldHRpbmdzIG9mIHByZXZpb3VzIHNlY3Rpb25zIGZvciBzcGVjaWFsIHByb2dyYW1zPC9lbnRyeT4KICAgICAgICAgICAgICA8L3Jvdz4KICAgICAgICAgICAgPC90Ym9keT4KICAgICAgICAgIDwvdGdyb3VwPgogICAgICAgIDwvaW5mb3JtYWx0YWJsZT4KCiAgICAgICAgPHBhcmE+CgkgIE5vdyBsZXQncyBleHBsYWluIHRoZSBjb25maWd1cmF0aW9uIGZpbGUgc2VjdGlvbnMgaW4gYQoJICBkZXRhaWxlZCB3YXkuCgk8L3BhcmE+CgkKICAgICAgICA8c2VjdDM+CiAgICAgICAgICA8dGl0bGU+VGhlIFtEcml2ZSB4XSBTZWN0aW9uczwvdGl0bGU+CiAgICAgICAgICA8cGFyYT4KCSAgICBGb3IgYSBkZXRhaWxlZCBkZXNjcmlwdGlvbiBvZiB0aGVzZSBjb25maWd1cmF0aW9uIGZpbGUKCSAgICBzZWN0aW9ucyB3aGljaCBhcmUgdXNlZCB0byBzZXQgdXAgRE9TIGRyaXZlIG1hcHBpbmdzIHRvIFVuaXgKCSAgICBkaXJlY3Rvcnkgc3BhY2UsIHBsZWFzZSBsb29rIGF0IHRoZSA8bGluawoJICAgIGxpbmtlbmQ9ImNvbmZpZy1kcml2ZS1zZWN0aW9ucyI+V2luZSBmaWxlIHN5c3RlbSBsYXllcgoJICAgIGNvbmZpZ3VyYXRpb24gc2VjdGlvbjwvbGluaz4uCgkgIDwvcGFyYT4KCTwvc2VjdDM+CgogICAgICAgIDxzZWN0MyBpZD0iY29uZmlnLXdpbmUiPgogICAgICAgICAgPHRpdGxlPlRoZSBbd2luZV0gU2VjdGlvbiA8L3RpdGxlPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIFRoZSBbd2luZV0gc2VjdGlvbiBvZiB0aGUgY29uZmlndXJhdGlvbiBmaWxlIGNvbnRhaW5zIGFsbCBraW5kcwogICAgICAgICAgICBvZiBnZW5lcmFsIHNldHRpbmdzIGZvciBXaW5lLgogIAkgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+CiJXaW5kb3dzIiA9ICJjOlxcd2luZG93cyIKIlN5c3RlbSIgPSAiYzpcXHdpbmRvd3NcXHN5c3RlbSIKIlRlbXAiID0gImM6XFx0ZW1wIgoiUGF0aCIgPSAiYzpcXHdpbmRvd3M7YzpcXHdpbmRvd3NcXHN5c3RlbTtjOlxcYmxhbmNvIgoiU2hvd0RpclN5bWxpbmtzIiA9ICIxIgogICAgICAgICAgICA8L3Byb2dyYW1saXN0aW5nPgoJICAgIEZvciBhIGRldGFpbGVkIGRlc2NyaXB0aW9uIG9mIGRyaXZlIGxheWVyIGNvbmZpZ3VyYXRpb24gYW5kCgkgICAgdGhlIG1lYW5pbmcgb2YgdGhlc2UgcGFyYW1ldGVycywgcGxlYXNlIGxvb2sgYXQgdGhlIDxsaW5rCgkgICAgbGlua2VuZD0iY29uZmlnLWRyaXZlLW1haW4iPldpbmUgZmlsZSBzeXN0ZW0gbGF5ZXIKCSAgICBjb25maWd1cmF0aW9uIHNlY3Rpb248L2xpbms+LgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4iR3JhcGhpY3NEcml2ZXIiID0gIngxMWRydnx0dHlkcnYiPC9wcm9ncmFtbGlzdGluZz4KICAJICAgIFNldHMgdGhlIGdyYXBoaWNzIGRyaXZlciB0byB1c2UgZm9yIFdpbmUgb3V0cHV0LgogIAkgICAgeDExZHJ2IGlzIGZvciBYMTEgb3V0cHV0LCB0dHlkcnYgaXMgZm9yIHRleHQgY29uc29sZSBvdXRwdXQuCiAgCSAgICBXQVJOSU5HOiBpZiB5b3UgdXNlIHR0eWRydiBoZXJlLCB0aGVuIHlvdSB3b24ndCBiZSBhYmxlIHRvIHJ1bgogIAkgICAgYSBsb3Qgb2YgV2luZG93cyBHVUkgcHJvZ3JhbXMgKHR0eWRydiBpcyBzdGlsbCBwcmV0dHkgImJyb2tlbiIKICAJICAgIGF0IHJ1bm5pbmcgZ3JhcGhpY2FsIGFwcHMpLiBUaHVzIHRoaXMgb3B0aW9uIGlzIG1haW5seSBpbnRlcmVzdGluZwogIAkgICAgZm9yIGUuZy4gZW1iZWRkZWQgdXNlIG9mIFdpbmUgaW4gd2ViIHNlcnZlciBzY3JpcHRzLgogIAkgICAgTm90ZSB0aGF0IHR0eWRydiBpcyBzdGlsbCB2ZXJ5IGxhY2tpbmcsIHNvIGlmIGl0IGRvZXNuJ3Qgd29yaywKICAJICAgIHJlc29ydCB0byB1c2luZyAieHZmYiIsIGEgdmlydHVhbCBYMTEgc2VydmVyLgogIAkgICAgQW5vdGhlciB3YXkgdG8gcnVuIFdpbmUgd2l0aG91dCBkaXNwbGF5IHdvdWxkIGJlIHRvIHJ1biBYMTEKICAJICAgIHZpYSBYdm5jLCB0aGVuIGNvbm5lY3QgdG8gdGhhdCBWTkMgZGlzcGxheSB1c2luZyB4dm5jdmlld2VyCiAgCSAgICAodGhhdCB3YXkgeW91J3JlIHN0aWxsIGFibGUgdG8gY29ubmVjdCB0byB5b3VyIGFwcCBhbmQKICAJICAgIGNvbmZpZ3VyZSBpdCBpZiBuZWVkIGJlKS4KICAJICA8L3BhcmE+CiAgCSAgPHBhcmE+CiAgICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4iUHJpbnRlciIgPSAib2ZmfG9uIjwvcHJvZ3JhbWxpc3Rpbmc+IFRlbGxzIHdpbmUKICAgICAgICAgICAgd2hldGhlciB0byBhbGxvdyBwcmludGluZyB2aWEgcHJpbnRlciBkcml2ZXJzIHRvIHdvcmsuCiAgCSAgICBUaGlzIG9wdGlvbiBpc24ndCBuZWVkZWQgZm9yIG91ciBidWlsdC1pbiBwc2RydiBwcmludGVyIGRyaXZlcgogIAkgICAgYXQgYWxsLgogICAgICAgICAgICBVc2luZyB0aGVzZSB0aGluZ3MgYXJlIHByZXR0eSBhbHBoYSwgc28geW91IG1pZ2h0IHdhbnQgdG8KICAgICAgICAgICAgd2F0Y2ggb3V0LiBTb21lIHBlb3BsZSBtaWdodCBmaW5kIGl0IHVzZWZ1bCwgaG93ZXZlci4gSWYKICAgICAgICAgICAgeW91J3JlIG5vdCBwbGFubmluZyB0byB3b3JrIG9uIHByaW50aW5nIHZpYSB3aW5kb3dzIHByaW50ZXIKICAJICAgIGRyaXZlcnMsIGRvbid0IGV2ZW4gYWRkIHRoaXMgdG8geW91ciB3aW5lIGNvbmZpZ3VyYXRpb24gZmlsZQogIAkgICAgKEl0IHByb2JhYmx5IGlzbid0IGFscmVhZHkgaW4gaXQpLgogIAkgICAgQ2hlY2sgb3V0IHRoZSBbc3Bvb2xlcl0gYW5kIFtwYXJhbGxlbHBvcnRzXSBzZWN0aW9ucyB0b28uCiAgICAgICAgICA8L3BhcmE+CiAgCSAgPHBhcmE+CiAgCSAgICA8cHJvZ3JhbWxpc3Rpbmc+IlNoZWxsTGlua2VyIiA9ICJ3aW5lc2hlbGxsaW5rIjwvcHJvZ3JhbWxpc3Rpbmc+CiAgCSAgICBUaGlzIHNldHRpbmcgc3BlY2lmaWVzIHRoZSBzaGVsbCBsaW5rZXIgc2NyaXB0IHRvIHVzZSBmb3Igc2V0dGluZwogIAkgICAgdXAgV2luZG93cyBpY29ucyBpbiBlLmcuIEtERSBvciBHbm9tZSB0aGF0IGFyZSBnaXZlbiBieSBwcm9ncmFtcwogIAkgICAgbWFraW5nIHVzZSBvZiBhcHByb3ByaWF0ZSBzaGVsbDMyLmRsbCBmdW5jdGlvbmFsaXR5IHRvIGNyZWF0ZQogIAkgICAgaWNvbnMgb24gdGhlIGRlc2t0b3Avc3RhcnQgbWVudSBkdXJpbmcgaW5zdGFsbGF0aW9uLgogIAkgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+IlN5bWJvbFRhYmxlRmlsZSIgPSAid2luZS5zeW0iPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgICAgU2V0cyB1cCB0aGUgc3ltYm9sIHRhYmxlIGZpbGUgZm9yIHRoZSB3aW5lIGRlYnVnZ2VyLiBZb3UKICAgICAgICAgICAgcHJvYmFibHkgZG9uJ3QgbmVlZCB0byBmaWRkbGUgd2l0aCB0aGlzLiBNYXkgYmUgdXNlZnVsIGlmCiAgICAgICAgICAgIHlvdXIgd2luZSBpcyBzdHJpcHBlZC4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICA8L3NlY3QzPgoKICAgICAgICA8c2VjdDMgaWQ9ImNvbmZpZy1kbGxkZWZhdWx0cyI+CiAgICAgICAgICA8dGl0bGU+VGhlIFtEbGxEZWZhdWx0c10gU2VjdGlvbjwvdGl0bGU+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgVGhlc2Ugc2V0dGluZ3MgcHJvdmlkZSB3aW5lJ3MgZGVmYXVsdCBoYW5kbGluZyBvZiBETEwgbG9hZGluZy4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+IkRlZmF1bHRMb2FkT3JkZXIiID0iIG5hdGl2ZSwgYnVpbHRpbiI8L3Byb2dyYW1saXN0aW5nPgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIFRoaXMgc2V0dGluZyBpcyBhIGNvbW1hLWRlbGltaXRlZCBsaXN0IG9mIHRoZSBvcmRlciBpbgogICAgICAgICAgICB3aGljaCB0byBhdHRlbXB0IGxvYWRpbmcgRExMcy4gSWYgdGhlIGZpcnN0IG9wdGlvbiBmYWlscywKICAgICAgICAgICAgaXQgd2lsbCB0cnkgdGhlIHNlY29uZCwgYW5kIHNvIG9uLiBUaGUgb3JkZXIgc3BlY2lmaWVkCiAgICAgICAgICAgIGFib3ZlIGlzIHByb2JhYmx5IHRoZSBiZXN0IGluIG1vc3QgY29uZGl0aW9ucy4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICA8L3NlY3QzPgoKICAgICAgICA8c2VjdDM+CiAgICAgICAgICA8dGl0bGU+VGhlIFtEbGxQYWlyc10gU2VjdGlvbjwvdGl0bGU+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgIEF0IG9uZSB0aW1lLCB0aGVyZSB3YXMgYSBzZWN0aW9uIGNhbGxlZCBbRGxsUGFpcnNdIGluIHRoZQogICAgICAgICAgZGVmYXVsdCBjb25maWd1cmF0aW9uIGZpbGUsIGJ1dCB0aGlzIGhhcyBiZWVuIG9ic29sZXRlZAogICAgICAgICAgYmVjYXVzZSB0aGUgcGFpcmluZyBpbmZvcm1hdGlvbiBoYXMgbm93IGJlZW4gZW1iZWRkZWQgaW50bwogICAgICAgICAgV2luZSBpdHNlbGYuIChUaGUgcHVycG9zZSBvZiB0aGlzIHNlY3Rpb24gd2FzIG1lcmVseSB0byBiZQogICAgICAgICAgYWJsZSB0byBpc3N1ZSB3YXJuaW5ncyBpZiB0aGUgdXNlciBhdHRlbXB0ZWQgdG8gcGFpcgogICAgICAgICAgY29kZXBlbmRlbnQgMTYtYml0LzMyLWJpdCBETExzIG9mIGRpZmZlcmVudCB0eXBlcy4pIElmIHlvdQogICAgICAgICAgc3RpbGwgaGF2ZSB0aGlzIGluIHlvdXIgPGZpbGVuYW1lPn4vLndpbmUvLmNvbmZpZzwvZmlsZW5hbWU+IG9yCiAgICAgICAgICA8ZmlsZW5hbWU+d2luZS5jb25mPC9maWxlbmFtZT4sIHlvdSBtYXkgc2FmZWx5IGRlbGV0ZSBpdC4KICAgICAgICAgIDwvcGFyYT4KICAJPC9zZWN0Mz4KCiAgICAgICAgPHNlY3QzIGlkPSJjb25maWctZGxsb3ZlcnJpZGVzIj4KICAgICAgICAgIDx0aXRsZT5UaGUgW0RsbE92ZXJyaWRlc10gU2VjdGlvbjwvdGl0bGU+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgVGhlIGZvcm1hdCBmb3IgdGhpcyBzZWN0aW9uIGlzIHRoZSBzYW1lIGZvciBlYWNoIGxpbmU6CiAgICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4KICAmbHQ7RExMPnssJmx0O0RMTD4sJmx0O0RMTD4uLi59ID0gJmx0O0ZPUk0+eywmbHQ7Rk9STT4sJmx0O0ZPUk0+Li4ufQogICAgICAgICAgICA8L3Byb2dyYW1saXN0aW5nPgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIEZvciBleGFtcGxlLCB0byBsb2FkIGJ1aWx0LWluIEtFUk5FTCBwYWlyIChjYXNlIGRvZXNuJ3QKICAgICAgICAgICAgbWF0dGVyIGhlcmUpOgogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+CiAgImtlcm5lbCxrZXJuZWwzMiIgPSAiYnVpbHRpbiIKICAgICAgICAgICAgPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICBUbyBsb2FkIHRoZSBuYXRpdmUgQ09NTURMRyBwYWlyLCBidXQgaWYgdGhhdCBkb2Vzbid0IHdvcmsKICAgICAgICAgICAgdHJ5IGJ1aWx0LWluOgogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+CiAgImNvbW1kbGcsY29tZGxnMzIiID0gIm5hdGl2ZSwgYnVpbHRpbiIKICAgICAgICAgICAgPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICBUbyBsb2FkIHRoZSBuYXRpdmUgQ09NQ1RMMzI6CiAgICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4KICAiY29tY3RsMzIiID0gIm5hdGl2ZSIKICAgICAgICAgICAgPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICBIZXJlIGlzIGEgZ29vZCBnZW5lcmljIHNldHVwIChBcyBpdCBpcyBkZWZpbmVkIGluIGNvbmZpZwogICAgICAgICAgICB0aGF0IHdhcyBpbmNsdWRlZCB3aXRoIHlvdXIgd2luZSBwYWNrYWdlKToKICAgICAgICAgICAgPHByb2dyYW1saXN0aW5nPgogIFtEbGxPdmVycmlkZXNdCiAgInJwY3J0NCIgICAgICAgPSAiYnVpbHRpbiwgbmF0aXZlIgogICJvbGVhdXQzMiIgICAgID0gImJ1aWx0aW4sIG5hdGl2ZSIKICAib2xlMzIiICAgICAgICA9ICJidWlsdGluLCBuYXRpdmUiCiAgImNvbW1kbGciICAgICAgPSAiYnVpbHRpbiwgbmF0aXZlIgogICJjb21kbGczMiIgICAgID0gImJ1aWx0aW4sIG5hdGl2ZSIKICAidmVyIiAgICAgICAgICA9ICJidWlsdGluLCBuYXRpdmUiCiAgInZlcnNpb24iICAgICAgPSAiYnVpbHRpbiwgbmF0aXZlIgogICJzaGVsbCIgICAgICAgID0gImJ1aWx0aW4sIG5hdGl2ZSIKICAic2hlbGwzMiIgICAgICA9ICJidWlsdGluLCBuYXRpdmUiCiAgInNoZm9sZGVyIiAgICAgPSAiYnVpbHRpbiwgbmF0aXZlIgogICJzaGx3YXBpIiAgICAgID0gImJ1aWx0aW4sIG5hdGl2ZSIKICAic2hkb2N2dyIgICAgICA9ICJidWlsdGluLCBuYXRpdmUiCiAgImx6ZXhwYW5kIiAgICAgPSAiYnVpbHRpbiwgbmF0aXZlIgogICJsejMyIiAgICAgICAgID0gImJ1aWx0aW4sIG5hdGl2ZSIKICAiY29tY3RsMzIiICAgICA9ICJidWlsdGluLCBuYXRpdmUiCiAgImNvbW1jdHJsIiAgICAgPSAiYnVpbHRpbiwgbmF0aXZlIgogICJhZHZhcGkzMiIgICAgID0gImJ1aWx0aW4sIG5hdGl2ZSIKICAiY3J0ZGxsIiAgICAgICA9ICJidWlsdGluLCBuYXRpdmUiCiAgIm1wciIgICAgICAgICAgPSAiYnVpbHRpbiwgbmF0aXZlIgogICJ3aW5zcG9vbC5kcnYiID0gImJ1aWx0aW4sIG5hdGl2ZSIKICAiZGRyYXciICAgICAgICA9ICJidWlsdGluLCBuYXRpdmUiCiAgImRpbnB1dCIgICAgICAgPSAiYnVpbHRpbiwgbmF0aXZlIgogICJkc291bmQiICAgICAgID0gImJ1aWx0aW4sIG5hdGl2ZSIKICAib3BlbmdsMzIiICAgICA9ICJidWlsdGluLCBuYXRpdmUiCiAgIm1zdmNydCIgICAgICAgPSAibmF0aXZlLCBidWlsdGluIgogICJtc3ZpZGVvIiAgICAgID0gImJ1aWx0aW4sIG5hdGl2ZSIKICAibXN2ZnczMiIgICAgICA9ICJidWlsdGluLCBuYXRpdmUiCiAgIm1jaWNkYS5kcnYiICAgPSAiYnVpbHRpbiwgbmF0aXZlIgogICJtY2lzZXEuZHJ2IiAgID0gImJ1aWx0aW4sIG5hdGl2ZSIKICAibWNpd2F2ZS5kcnYiICA9ICJidWlsdGluLCBuYXRpdmUiCiAgIm1jaWF2aS5kcnYiICAgPSAibmF0aXZlLCBidWlsdGluIgogICJtY2lhbmltLmRydiIgID0gIm5hdGl2ZSwgYnVpbHRpbiIKICAibXNhY20uZHJ2IiAgICA9ICJidWlsdGluLCBuYXRpdmUiCiAgIm1zYWNtIiAgICAgICAgPSAiYnVpbHRpbiwgbmF0aXZlIgogICJtc2FjbTMyIiAgICAgID0gImJ1aWx0aW4sIG5hdGl2ZSIKICAibWlkaW1hcC5kcnYiICA9ICJidWlsdGluLCBuYXRpdmUiCiAgOyB5b3UgY2FuIHNwZWNpZnkgcHJvZ3JhbXMgdG9vCiAgIm5vdGVwYWQuZXhlIiAgPSAibmF0aXZlLCBidWlsdGluIgogIDsgZGVmYXVsdCBmb3IgYWxsIG90aGVyIERMTHMKICAiKiIgPSAibmF0aXZlLCBidWlsdGluIgogICAgICAgICAgICA8L3Byb2dyYW1saXN0aW5nPgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPG5vdGU+CiAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgIElmIGxvYWRpbmcgb2YgdGhlIGxpYnJhcmllcyB0aGF0IGFyZSBsaXN0ZWQgZmlyc3QgZmFpbHMsCiAgICAgICAgICAgICAgd2luZSB3aWxsIGp1c3QgZ28gb24gYnkgdXNpbmcgdGhlIHNlY29uZCBvciB0aGlyZCBvcHRpb24uCiAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDwvbm90ZT4KICAgICAgICA8L3NlY3QzPgoKICAgICAgICA8c2VjdDMgaWQ9ImNvbmZpZy1mb250cyI+CiAgICAgICAgICA8dGl0bGU+VGhlIFtmb250c10gU2VjdGlvbjwvdGl0bGU+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgVGhpcyBzZWN0aW9uIHNldHMgdXAgd2luZSdzIGZvbnQgaGFuZGxpbmcuCiAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgPHByb2dyYW1saXN0aW5nPiJSZXNvbHV0aW9uIiA9ICI5NiI8L3Byb2dyYW1saXN0aW5nPgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIFNpbmNlIHRoZSB3YXkgWCBoYW5kbGVzIGZvbnRzIGlzIGRpZmZlcmVudCBmcm9tIHRoZSB3YXkKICAgICAgICAgICAgV2luZG93cyBkb2VzLCB3aW5lIHVzZXMgYSBzcGVjaWFsIG1lY2hhbmlzbSB0byBkZWFsIHdpdGgKICAgICAgICAgICAgdGhlbS4gSXQgbXVzdCBzY2FsZSB0aGVtIHVzaW5nIHRoZSBudW1iZXIgZGVmaW5lZCBpbiB0aGUKICAgICAgICAgICAgIlJlc29sdXRpb24iIHNldHRpbmcuIDYwLTEyMCBhcmUgcmVhc29uYWJsZSB2YWx1ZXMsIDk2IGlzCiAgICAgICAgICAgIGEgbmljZSBpbiB0aGUgbWlkZGxlIG9uZS4gSWYgeW91IGhhdmUgdGhlIHJlYWwgd2luZG93cwogICAgICAgICAgICBmb250cyBhdmFpbGFibGUgKDxmaWxlbmFtZT4mbHQ7ZGlycyB0bwogICAgICAgICAgICAgIHdpbmU+L2RvY3VtZW50YXRpb24vdHRmc2VydmVyPC9maWxlbmFtZT4gYW5kCiAgICAgICAgICAgIDxmaWxlbmFtZT5mb250czwvZmlsZW5hbWU+KSwgdGhpcyBwYXJhbWV0ZXIgd2lsbCBub3QgYmUgYXMKICAgICAgICAgICAgaW1wb3J0YW50LiBPZiBjb3Vyc2UsIGl0J3MgYWx3YXlzIGdvb2QgdG8gZ2V0IHlvdXIgWCBmb250cwogICAgICAgICAgICB3b3JraW5nIGFjY2VwdGFibHkgaW4gd2luZS4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+IkRlZmF1bHQiID0gIi1hZG9iZS10aW1lcy0iPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgICAgVGhlIGRlZmF1bHQgZm9udCB3aW5lIHVzZXMuIEZvb2wgYXJvdW5kIHdpdGggaXQgaWYgeW91J2QgbGlrZS4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogIE9QVElPTkFMOgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIFRoZSA8bGl0ZXJhbD5BbGlhczwvbGl0ZXJhbD4gc2V0dGluZyBhbGxvd3MgeW91IHRvIG1hcCBhbiBYIGZvbnQgdG8gYSBmb250CiAgICAgICAgICAgIHVzZWQgaW4gd2luZS4gVGhpcyBpcyBnb29kIGZvciBhcHBzIHRoYXQgbmVlZCBhIHNwZWNpYWwgZm9udCB5b3UgZG9uJ3QgaGF2ZSwKICAgICAgICAgICAgYnV0IGEgZ29vZCByZXBsYWNlbWVudCBleGlzdHMuIFRoZSBzeW50YXggaXMgbGlrZSBzbzoKICAgICAgICAgICAgPHByb2dyYW1saXN0aW5nPgogICJBbGlhc1giID0gIltGYWtlIHdpbmRvd3MgbmFtZV0sW1JlYWwgWCBuYW1lXSImbHQ7LG9wdGlvbmFsICJtYXNraW5nIiBzZWN0aW9uPgogICAgICAgICAgICA8L3Byb2dyYW1saXN0aW5nPgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIFByZXR0eSBzdHJhaWdodGZvcndhcmQuIFJlcGxhY2UgIkFsaWFzWCIgd2l0aCAiQWxpYXMwIiwKICAgICAgICAgICAgdGhlbiAiQWxpYXMxIiBhbmQgc28gb24uIFRoZSBmYWtlIHdpbmRvd3MgbmFtZSBpcyB0aGUgbmFtZQogICAgICAgICAgICB0aGF0IHRoZSBmb250IHdpbGwgYmUgdW5kZXIgYSB3aW5kb3dzIGFwcCBpbiB3aW5lLiBUaGUKICAgICAgICAgICAgcmVhbCBYIG5hbWUgaXMgdGhlIGZvbnQgbmFtZSBhcyBzZWVuIGJ5IFggKFJ1bgogICAgICAgICAgICAieGZvbnRzZWwiKS4gVGhlIG9wdGlvbmFsICJtYXNraW5nIiBzZWN0aW9uIGFsbG93cyB5b3UgdG8KICAgICAgICAgICAgdXRpbGl6ZSB0aGUgZmFrZSB3aW5kb3dzIG5hbWUgeW91IGRlZmluZS4gSWYgaXQgaXMgbm90CiAgICAgICAgICAgIHVzZWQsIHRoZW4gd2luZSB3aWxsIGp1c3QgdHJ5IHRvIGV4dHJhY3QgdGhlIGZha2Ugd2luZG93cwogICAgICAgICAgICBuYW1lIGl0c2VsZiBhbmQgbm90IHVzZSB0aGUgdmFsdWUgeW91IGVudGVyLgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIEhlcmUgaXMgYW4gZXhhbXBsZSBvZiBhbiBhbGlhcyB3aXRob3V0IG1hc2tpbmcuIFRoZSBmb250IHdpbGwgc2hvdyB1cCBpbiB3aW5kb3dzCiAgICAgICAgICAgIGFwcHMgYXMgIkdvb2dsZSIuCgogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+CiAgIkFsaWFzMCIgPSAiRm9vLC0tZ29vZ2xlLSIKICAgICAgICAgICAgPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICBIZXJlIGlzIGFuIGV4YW1wbGUgd2l0aCBtYXNraW5nIGVuYWJsZWQuIFRoZSBmb250IHdpbGwgc2hvdyB1cCBhcyAiRm9vIiBpbgogICAgICAgICAgICB3aW5kb3dzIGFwcHMuCiAgICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4KICAiQWxpYXMxIiA9ICJGb28sLS1nb29nbGUtLHN1YnN0IgogICAgICAgICAgICA8L3Byb2dyYW1saXN0aW5nPgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIEZvciBtb3JlIGluZm9ybWF0aW9uIGNoZWNrIG91dCB0aGUgPGxpbmsgbGlua2VuZD0iY29uZmlnLWZvbnRzLW1haW4iPkZvbnRzPC9saW5rPgogIAkgICAgY2hhcHRlci4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICA8L3NlY3QzPgoKICAgICAgICA8c2VjdDMgaWQ9ImNvbmZpZy1pbyI+CiAgICAgICAgICA8dGl0bGU+VGhlIFtzZXJpYWxwb3J0c10sIFtwYXJhbGxlbHBvcnRzXSwgW3Nwb29sZXJdLCBhbmQgW3BvcnRzXSBTZWN0aW9uczwvdGl0bGU+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgRXZlbiB0aG91Z2ggaXQgc291bmRzIGxpa2UgYSBsb3Qgb2Ygc2VjdGlvbnMsIHRoZXNlIGFyZQogICAgICAgICAgICBhbGwgY2xvc2VseSByZWxhdGVkLiBUaGV5IGFyZSBhbGwgZm9yIGNvbW11bmljYXRpb25zIGFuZAogICAgICAgICAgICBwYXJhbGxlbCBwb3J0cy4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICBUaGUgW3NlcmlhbHBvcnRzXSBzZWN0aW9uIHRlbGxzIHdpbmUgd2hhdCBzZXJpYWwgcG9ydHMgaXQKICAgICAgICAgICAgaXMgYWxsb3dlZCB0byB1c2UuCiAgICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4iQ29tWCIgPSAiL2Rldi90dHlTWSI8L3Byb2dyYW1saXN0aW5nPgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIFJlcGxhY2UgPGxpdGVyYWw+WDwvbGl0ZXJhbD4gd2l0aCB0aGUgbnVtYmVyIG9mIHRoZSBDT00KICAgICAgICAgICAgcG9ydCBpbiBXaW5kb3dzICgxLTgpIGFuZCA8bGl0ZXJhbD5ZPC9saXRlcmFsPiB3aXRoIHRoZQogICAgICAgICAgICBudW1iZXIgb2YgaXQgaW4gPGxpdGVyYWw+WDwvbGl0ZXJhbD4gKFVzdWFsbHkgdGhlIG51bWJlcgogICAgICAgICAgICBvZiB0aGUgcG9ydCBpbiBXaW5kb3dzIG1pbnVzIDEpLiA8bGl0ZXJhbD5Db21YPC9saXRlcmFsPgogICAgICAgICAgICBjYW4gYWN0dWFsbHkgZXF1YWwgYW55IGRldmljZQogICAgICAgICAgICAoPG1lZGlhbGFiZWw+L2Rldi9tb2RlbTwvbWVkaWFsYWJlbD4gaXMgYWNjZXB0YWJsZSkuIEl0IGlzCiAgICAgICAgICAgIG5vdCBhbHdheXMgbmVjZXNzYXJ5IHRvIGRlZmluZSBhbnkgQ09NIHBvcnRzIChBbiBvcHRpb25hbAogICAgICAgICAgICBzZXR0aW5nKS4gSGVyZSBpcyBhbiBleGFtcGxlOgogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+IkNvbTEiID0gIi9kZXYvdHR5UzAiPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICBVc2UgYXMgbWFueSBvZiB0aGVzZSBhcyB5b3UgbGlrZSBpbiB0aGUgc2VjdGlvbiB0byBkZWZpbmUKICAgICAgICAgICAgYWxsIG9mIHRoZSBDT00gcG9ydHMgeW91IG5lZWQuCiAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgVGhlIFtwYXJhbGxlbHBvcnRzXSBzZWN0aW9uIHNldHMgdXAgYW55IHBhcmFsbGVsIHBvcnRzCiAgICAgICAgICAgIHRoYXQgd2lsbCBiZSBhbGxvd2VkIGFjY2VzcyB1bmRlciB3aW5lLgogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+IkxwdFgiID0gIi9kZXYvbHBZIjwvcHJvZ3JhbWxpc3Rpbmc+CiAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgU291bmRzIGZhbWlsaWFyPyBTeW50YXggaXMganVzdCBsaWtlIHRoZSBDT00gcG9ydCBzZXR0aW5nLgogICAgICAgICAgICBSZXBsYWNlIDxsaXRlcmFsPlg8L2xpdGVyYWw+IHdpdGggYSB2YWx1ZSBmcm9tIDEtNCBhcyBpdAogICAgICAgICAgICBpcyBpbiBXaW5kb3dzIGFuZCA8bGl0ZXJhbD5ZPC9saXRlcmFsPiB3aXRoIGEgdmFsdWUgZnJvbQogICAgICAgICAgICAwLTMgKDxsaXRlcmFsPlk8L2xpdGVyYWw+IGlzIHVzdWFsbHkgdGhlIHZhbHVlIGluIHdpbmRvd3MKICAgICAgICAgICAgbWludXMgMSwganVzdCBsaWtlIGZvciBDT00gcG9ydHMpLiBZb3UgZG9uJ3QgYWx3YXlzIG5lZWQKICAgICAgICAgICAgdG8gZGVmaW5lIGEgcGFyYWxsZWwgcG9ydCAoQUtBLCBpdCdzIG9wdGlvbmFsKS4gQXMgd2l0aAogICAgICAgICAgICB0aGUgb3RoZXIgc2VjdGlvbiwgTHB0WCBjYW4gZXF1YWwgYW55IGRldmljZSAoTWF5YmUKICAgICAgICAgICAgPG1lZGlhbGFiZWw+L2Rldi9wcmludGVyPC9tZWRpYWxhYmVsPikuIEhlcmUgaXMgYW4KICAgICAgICAgICAgZXhhbXBsZTogIDxwcm9ncmFtbGlzdGluZz4iTHB0MSIgPSAiL2Rldi9scDAiPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICBUaGUgW3Nwb29sZXJdIHNlY3Rpb24gd2lsbCBpbmZvcm0gd2luZSB3aGVyZSB0byBzcG9vbAogICAgICAgICAgICBwcmludCBqb2JzLiBVc2UgdGhpcyBpZiB5b3Ugd2FudCB0byB0cnkgcHJpbnRpbmcuIFdpbmUKICAgICAgICAgICAgZG9jcyBjbGFpbSB0aGF0IHNwb29saW5nIGlzICJyYXRoZXIgcHJpbWl0aXZlIiBhdCB0aGlzCiAgICAgICAgICAgIHRpbWUsIHNvIGl0IHdvbid0IHdvcmsgcGVyZmVjdGx5LiA8ZW1waGFzaXM+SXQgaXMgb3B0aW9uYWwuPC9lbXBoYXNpcz4gVGhlIG9ubHkKICAgICAgICAgICAgc2V0dGluZyB5b3UgdXNlIGluIHRoaXMgc2VjdGlvbiB3b3JrcyB0byBtYXAgYSBwb3J0IChMUFQxLAogICAgICAgICAgICBmb3IgZXhhbXBsZSkgdG8gYSBmaWxlIG9yIGEgY29tbWFuZC4gSGVyZSBpcyBhbiBleGFtcGxlLAogICAgICAgICAgICBtYXBwaW5nIExQVDEgdG8gdGhlIGZpbGUgPGZpbGVuYW1lPm91dC5wczwvZmlsZW5hbWU+OgogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+IkxQVDE6IiA9ICJvdXQucHMiPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICBUaGUgZm9sbG93aW5nIGNvbW1hbmQgbWFwcyBwcmludGluZyBqb2JzIHRvIExQVDEgdG8gdGhlCiAgICAgICAgICAgIGNvbW1hbmQgPGNvbW1hbmQ+bHByPC9jb21tYW5kPi4gTm90aWNlICB0aGUgfDoKICAgICAgICAgICAgPHByb2dyYW1saXN0aW5nPiJMUFQxOiIgPSAifGxwciI8L3Byb2dyYW1saXN0aW5nPgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIFRoZSBbcG9ydHNdIHNlY3Rpb24gaXMgdXN1YWxseSB1c2VmdWwgb25seSBmb3IgcGVvcGxlIHdobwogICAgICAgICAgICBuZWVkIGRpcmVjdCBwb3J0IGFjY2VzcyBmb3IgcHJvZ3JhbXMgcmVxdWlyaW5nIGRvbmdsZXMgb3IKICAgICAgICAgICAgc2Nhbm5lcnMuIDxlbXBoYXNpcz5JZiB5b3UgZG9uJ3QgbmVlZCBpdCwgZG9uJ3QgdXNlCgkgICAgaXQhPC9lbXBoYXNpcz4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+InJlYWQiID0gIjB4Nzc5LDB4Mzc5LDB4MjgwLTB4MmEwIjwvcHJvZ3JhbWxpc3Rpbmc+CiAgICAgICAgICAgIEdpdmVzIGRpcmVjdCByZWFkIGFjY2VzcyB0byB0aG9zZSBJTydzLgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4id3JpdGUiID0gIjB4Nzc5LDB4Mzc5LDB4MjgwLTB4MmEwIjwvcHJvZ3JhbWxpc3Rpbmc+CiAgICAgICAgICAgIEdpdmVzIGRpcmVjdCB3cml0ZSBhY2Nlc3MgdG8gdGhvc2UgSU8ncy4gSXQncyBwcm9iYWJseSBhCiAgICAgICAgICAgIGdvb2QgaWRlYSB0byBrZWVwIHRoZSB2YWx1ZXMgb2YgdGhlCiAgICAgICAgICAgIDxsaXRlcmFsPnJlYWQ8L2xpdGVyYWw+IGFuZCA8bGl0ZXJhbD53cml0ZTwvbGl0ZXJhbD4KICAgICAgICAgICAgc2V0dGluZ3MgdGhlIHNhbWUuIFRoaXMgc3R1ZmYgd2lsbCBvbmx5IHdvcmsgd2hlbiB5b3UncmUKICAgICAgICAgICAgcm9vdC4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICA8L3NlY3QzPgoKICAgICAgICA8c2VjdDMgaWQ9ImNvbmZpZy1kZWJ1Zy1ldGMiPgogICAgICAgICAgPHRpdGxlPlRoZSBbRGVidWddLCBbUmVnaXN0cnldLCBbdHdlYWsubGF5b3V0XSwgYW5kIFtwcm9ncmFtc10gU2VjdGlvbnM8L3RpdGxlPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIFtEZWJ1Z10gaXMgdXNlZCB0byBpbmNsdWRlIG9yIGV4Y2x1ZGUgZGVidWcgbWVzc2FnZXMsIGFuZCB0bwogICAgICAgICAgICBvdXRwdXQgdGhlbSB0byBhIGZpbGUuIFRoZSBsYXR0ZXIgaXMgcmFyZWx5IHVzZWQuIDxlbXBoYXNpcz5UaGVzZQogICAgICAgICAgICBhcmUgYWxsIG9wdGlvbmFsIGFuZCB5b3UgcHJvYmFibHkgZG9uJ3QgbmVlZCB0byBhZGQgb3IKICAgICAgICAgICAgcmVtb3ZlIGFueXRoaW5nIGluIHRoaXMgc2VjdGlvbiB0byB5b3VyIGNvbmZpZy48L2VtcGhhc2lzPiAoSW4gZXh0cmVtZQogICAgICAgICAgICBjYXNlcyB5b3UgbWF5IHdhbnQgdG8gdXNlIHRoZXNlIG9wdGlvbnMgdG8gbWFuYWdlIHRoZSBhbW91bnQKICAgICAgICAgICAgb2YgaW5mb3JtYXRpb24gZ2VuZXJhdGVkIGJ5IHRoZSA8cGFyYW1ldGVyPi0tZGVidWdtc2cgK3JlbGF5CiAgICAgICAgICAgIDwvcGFyYW1ldGVyPiBvcHRpb24uKQogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4iRmlsZSIgPSAiL2JsYW5jbyI8L3Byb2dyYW1saXN0aW5nPgogICAgICAgICAgICBTZXRzIHRoZSBsb2dmaWxlIGZvciB3aW5lLiBTZXQgdG8gQ09OIHRvIGxvZyB0byBzdGFuZGFyZCBvdXQuCiAgICAgICAgICAgIDxlbXBoYXNpcz5UaGlzIGlzIHJhcmVseSB1c2VkLjwvZW1waGFzaXM+CiAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgPHByb2dyYW1saXN0aW5nPiJTcHlFeGNsdWRlIiA9ICJXTV9TSVpFO1dNX1RJTUVSOyI8L3Byb2dyYW1saXN0aW5nPgogICAgICAgICAgICBFeGNsdWRlcyBkZWJ1ZyBtZXNzYWdlcyBhYm91dCA8Y29uc3RhbnQ+V01fU0laRTwvY29uc3RhbnQ+CiAgICAgICAgICAgIGFuZCA8Y29uc3RhbnQ+V01fVElNRVI8L2NvbnN0YW50PiBpbiB0aGUgbG9nZmlsZS4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+IlNweUluY2x1ZGUiID0gIldNX1NJWkU7V01fVElNRVI7IjwvcHJvZ3JhbWxpc3Rpbmc+CiAgICAgICAgICAgIEluY2x1ZGVzIGRlYnVnIG1lc3NhZ2VzIGFib3V0IDxjb25zdGFudD5XTV9TSVpFPC9jb25zdGFudD4KICAgICAgICAgICAgYW5kIDxjb25zdGFudD5XTV9USU1FUjwvY29uc3RhbnQ+IGluIHRoZSBsb2dmaWxlLgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4iUmVsYXlJbmNsdWRlIiA9ICJ1c2VyMzIuQ3JlYXRlV2luZG93QTtjb21jdGwzMi4qIjwvcHJvZ3JhbWxpc3Rpbmc+CiAgICAgICAgICAgIEluY2x1ZGUgb25seSB0aGUgbGlzdGVkIGZ1bmN0aW9ucyBpbiBhCiAgICAgICAgICAgIDxwYXJhbWV0ZXI+LS1kZWJ1Z21zZyArcmVsYXk8L3BhcmFtZXRlcj4gdHJhY2UuICBUaGlzIGVudHJ5IGlzCiAgICAgICAgICAgIGlnbm9yZWQgaWYgdGhlcmUgaXMgYSA8cGFyYW1ldGVyPlJlbGF5RXhjbHVkZTwvcGFyYW1ldGVyPiBlbnRyeS4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+IlJlbGF5RXhjbHVkZSIgPSAiUnRsRW50ZXJDcml0aWNhbFNlY3Rpb247UnRsTGVhdmVDcml0aWNhbFNlY3Rpb24iPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgICAgRXhjbHVkZSB0aGUgbGlzdGVkIGZ1bmN0aW9ucyBpbiBhCiAgICAgICAgICAgIDxwYXJhbWV0ZXI+LS1kZWJ1Z21zZyArcmVsYXk8L3BhcmFtZXRlcj4gdHJhY2UuICBUaGlzIGVudHJ5CiAgICAgICAgICAgIG92ZXJyaWRlcyBhbnkgc2V0dGluZ3MgaW4gYSA8cGFyYW1ldGVyPlJlbGF5SW5jbHVkZTwvcGFyYW1ldGVyPgogICAgICAgICAgICBlbnRyeS4gIElmIG5laXRoZXIgZW50cnkgaXMgcHJlc2VudCB0aGVuIHRoZSB0cmFjZSBpbmNsdWRlcwogICAgICAgICAgICBldmVyeXRoaW5nLgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIEluIGJvdGggZW50cmllcyB0aGUgZnVuY3Rpb25zIG1heSBiZSBzcGVjaWZpZWQgZWl0aGVyIGFzIGEKICAgICAgICAgICAgZnVuY3Rpb24gbmFtZSBvciBhcyBhIG1vZHVsZSBhbmQgZnVuY3Rpb24uICBJbiB0aGlzIGxhdHRlcgogICAgICAgICAgICBjYXNlIHNwZWNpZnkgYW4gYXN0ZXJpc2sgZm9yIHRoZSBmdW5jdGlvbiBuYW1lIHRvIGluY2x1ZGUvZXhjbHVkZQogICAgICAgICAgICBhbGwgZnVuY3Rpb25zIGluIHRoZSBtb2R1bGUuCiAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgW1JlZ2lzdHJ5XSBjYW4gYmUgdXNlZCB0byB0ZWxsIHdpbmUgd2hlcmUgeW91ciBvbGQgd2luZG93cwogICAgICAgICAgICByZWdpc3RyeSBmaWxlcyBleGlzdC4gVGhpcyBzZWN0aW9uIGlzIGNvbXBsZXRlbHkgb3B0aW9uYWwKICAgICAgICAgICAgYW5kIHVzZWxlc3MgdG8gcGVvcGxlIHVzaW5nIHdpbmUgd2l0aG91dCBhbiBleGlzdGluZwogICAgICAgICAgICB3aW5kb3dzIGluc3RhbGxhdGlvbi4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+IlVzZXJGaWxlTmFtZSIgPSAiL2RpcnMvdG8vdXNlci5yZWciPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgICAgVGhlIGxvY2F0aW9uIG9mIHlvdXIgb2xkIDxmaWxlbmFtZT51c2VyLnJlZzwvZmlsZW5hbWU+IGZpbGUuCiAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgW3R3ZWFrLmxheW91dF0gaXMgZGV2b3RlZCB0byB3aW5lJ3MgbG9vay4gVGhlcmUgaXMgb25seQogICAgICAgICAgICBvbmUgc2V0dGluZyBmb3IgaXQuCiAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgPHByb2dyYW1saXN0aW5nPiJXaW5lTG9vayIgPSAid2luMzF8d2luOTV8d2luOTgiPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgICAgV2lsbCBjaGFuZ2UgdGhlIGxvb2sgb2Ygd2luZSBmcm9tIFdpbmRvd3MgMy4xIHRvIFdpbmRvd3MgOTUuCiAgICAgICAgICAgIFRoZSA8bGl0ZXJhbD53aW45ODwvbGl0ZXJhbD4gc2V0dGluZyBiZWhhdmVzCiAgICAgICAgICAgIGp1c3QgbGlrZSA8bGl0ZXJhbD53aW45NTwvbGl0ZXJhbD4gbW9zdCBvZiB0aGUgdGltZS4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICBbcHJvZ3JhbXNdIGNhbiBiZSB1c2VkIHRvIHNheSB3aGF0IHByb2dyYW1zIHJ1biB1bmRlcgogICAgICAgICAgICBzcGVjaWFsIGNvbmRpdGlvbnMuCiAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgPHByb2dyYW1saXN0aW5nPiJEZWZhdWx0IiA9ICIvcHJvZ3JhbS90by9leGVjdXRlLmV4ZSI8L3Byb2dyYW1saXN0aW5nPgogICAgICAgICAgICBTZXRzIHRoZSBwcm9ncmFtIHRvIGJlIHJ1biBpZiB3aW5lIGlzIHN0YXJ0ZWQgd2l0aG91dCBzcGVjaWZ5aW5nIGEgcHJvZ3JhbS4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+IlN0YXJ0dXAiID0gIi9wcm9ncmFtL3RvL2V4ZWN1dGUuZXhlIjwvcHJvZ3JhbWxpc3Rpbmc+CiAgICAgICAgICAgIFNldHMgdGhlIHByb2dyYW0gdG8gYXV0b21hdGljYWxseSBiZSBydW4gYXQgc3RhcnR1cCBldmVyeSB0aW1lLgogICAgICAgICAgPC9wYXJhPgogICAgICAgIDwvc2VjdDM+CgogICAgICAgIDxzZWN0MyBpZD0iY29uZmlnLXdpbm1tIj4KICAgICAgICAgIDx0aXRsZT5UaGUgW1dpbk1NXSBTZWN0aW9uPC90aXRsZT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICBbV2luTU1dIGlzIHVzZWQgdG8gZGVmaW5lIHdoaWNoIG11bHRpbWVkaWEgZHJpdmVycyBoYXZlIHRvIGJlIGxvYWRlZC4gU2luY2UKICAJICAgIHRob3NlIGRyaXZlcnMgbWF5IGRlcGVuZCBvbiB0aGUgbXVsdGltZWRpYSBpbnRlcmZhY2VzIGF2YWlsYWJsZSBvbiB5b3VyIHN5c3RlbQogIAkgICAgKE9TUywgQUxTQS4uLiB0byBuYW1lIGEgZmV3KSwgaXQncyBuZWVkZWQgdG8gYmUgYWJsZSB0byBjb25maWd1cmUgd2hpY2ggZHJpdmVyCiAgCSAgICBoYXMgdG8gYmUgbG9hZGVkLgogICAgICAgICAgPC9wYXJhPgoKICAgICAgICAgIDxwYXJhPgogIAkgICAgVGhlIGNvbnRlbnQgb2YgdGhlIHNlY3Rpb24gbG9va3MgbGlrZToKICAJICAgIDxwcm9ncmFtbGlzdGluZz4KW1dpbk1NXQoiRHJpdmVycyIgPSAid2luZW9zcy5kcnYiCiJXYXZlTWFwcGVyIiA9ICJtc2FjbS5kcnYiCiJNaWRpTWFwcGVyIiA9ICJtaWRpbWFwLmRydiIKICAJICAgIDwvcHJvZ3JhbWxpc3Rpbmc+CiAgCSAgICBBbGwgdGhlIGtleXMgbXVzdCBiZSBkZWZpbmVkOgogIAkgICAgPGl0ZW1pemVkbGlzdD4KICAJICAgICAgPGxpc3RpdGVtPgogIAkgICAgICAgIDxwYXJhPgogIAkJICBUaGUgIkRyaXZlcnMiIGtleSBpcyBhICc7JyBzZXBhcmF0ZWQgbGlzdCBvZiBtb2R1bGVzIG5hbWUsIGVhY2ggb2YKICAJCSAgdGhlbSBjb250YWluaW5nIGEgbG93IGxldmVsIGRyaXZlci4gQWxsIHRob3NlIGRyaXZlcnMgd2lsbCBiZSBsb2FkZWQKICAJCSAgd2hlbiBNTVNZU1RFTS9XSU5NTSBpcyBzdGFydGVkIGFuZCB3aWxsIHByb3ZpZGUgdGhlaXIgaW5uZXIgZmVhdHVyZXMuCiAgCSAgICAgICAgPC9wYXJhPgogIAkgICAgICA8L2xpc3RpdGVtPgogIAkgICAgICA8bGlzdGl0ZW0+CiAgCSAgICAgICAgPHBhcmE+CiAgCQkgIFRoZSAiV2F2ZU1hcHBlciIgcmVwcmVzZW50cyB0aGUgbmFtZSBvZiB0aGUgbW9kdWxlIGNvbnRhaW5pbmcgdGhlIFdhdmUKICAJCSAgTWFwcGVyIGRyaXZlci4gT25seSBvbmUgd2F2ZSBtYXBwZXIgY2FuIGJlIGRlZmluZWQgaW4gdGhlIHN5c3RlbS4KICAJICAgICAgICA8L3BhcmE+CiAgCSAgICAgIDwvbGlzdGl0ZW0+CiAgCSAgICAgIDxsaXN0aXRlbT4KICAJICAgICAgICA8cGFyYT4KICAJCSAgVGhlICJNaWRpTWFwcGVyIiByZXByZXNlbnRzIHRoZSBuYW1lIG9mIHRoZSBtb2R1bGUgY29udGFpbmluZyB0aGUgTUlESQogIAkJICBNYXBwZXIgZHJpdmVyLiBPbmx5IG9uZSBNSURJIG1hcHBlciBjYW4gYmUgZGVmaW5lZCBpbiB0aGUgc3lzdGVtLgogIAkgICAgICAgIDwvcGFyYT4KICAJICAgICAgPC9saXN0aXRlbT4KICAJICAgIDwvaXRlbWl6ZWRsaXN0PgogICAgICAgICAgPC9wYXJhPgogIAk8L3NlY3QzPgoKICAgICAgICA8c2VjdDMgaWQ9ImNvbmZpZy1uZXR3b3JrIj4KICAgICAgICAgIDx0aXRsZT5UaGUgW05ldHdvcmtdIFNlY3Rpb248L3RpdGxlPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIFtOZXR3b3JrXSBjb250YWlucyBzZXR0aW5ncyByZWxhdGVkIHRvCiAgICAgICAgICAgIG5ldHdvcmtpbmcuIEN1cnJlbnRseSB0aGVyZSBpcyBvbmx5IG9uZSB2YWx1ZSB0aGF0IGNhbiBiZSBzZXQuCiAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8dmFyaWFibGVsaXN0PgogICAgICAgICAgICA8dmFybGlzdGVudHJ5PgogICAgICAgICAgICAgIDx0ZXJtPlVzZURuc0NvbXB1dGVyTmFtZTwvdGVybT4KICAgICAgICAgICAgICA8bGlzdGl0ZW0+CiAgICAgICAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgICAgICAgQSBib29sZWFuIHNldHRpbmcgKGRlZmF1bHQ6IDxsaXRlcmFsPlk8L2xpdGVyYWw+KQogICAgICAgICAgICAgICAgICB0aGF0IGFmZmVjdHMgdGhlIHdheSBXaW5lIHNldHMgdGhlIGNvbXB1dGVyIG5hbWUuIFRoZSBjb21wdXRlcgogICAgICAgICAgICAgICAgICBuYW1lIGluIHRoZSBXaW5kb3dzIHdvcmxkIGlzIHRoZSBzby1jYWxsZWQgPGVtcGhhc2lzPk5ldEJJT1MgbmFtZTwvZW1waGFzaXM+LgogICAgICAgICAgICAgICAgICBJdCBpcyBjb250YWluZWQgaW4gdGhlIDx2YXJuYW1lPkNvbXB1dGVyTmFtZTwvdmFybmFtZT4gaW4gdGhlIHJlZ2lzdHJ5IGVudHJ5CiAgICAgICAgICAgICAgICAgIDx2YXJuYW1lPkhLRVlfTE9DQUxfTUFDSElORVxTeXN0ZW1cQ3VycmVudENvbnRyb2xTZXRcQ29udHJvbFxDb21wdXRlck5hbWVcQ29tcHV0ZXJOYW1lPC92YXJuYW1lPi4KICAgICAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgICAgICBJZiB0aGlzIG9wdGlvbiBpcyBzZXQgdG8gIlkiIG9yIG1pc3NpbmcsIFdpbmUgd2lsbCBzZXQgdGhlCiAgICAgICAgICAgICAgICAgIE5ldEJJT1MgbmFtZSB0byB0aGUgVW5peCBob3N0IG5hbWUgb2YgeW91ciBjb21wdXRlciwgaWYKICAgICAgICAgICAgICAgICAgbmVjZXNzYXJ5IHRydW5jYXRlZCB0byAzMSBjaGFyYWN0ZXJzLiBUaGUgVW5peCBob3N0bmFtZSBpcyB0aGUgb3V0cHV0CiAgICAgICAgICAgICAgICAgIG9mIHRoZSBzaGVsbCBjb21tYW5kIDxjb21tYW5kPmhvc3RuYW1lPC9jb21tYW5kPiwgdXAgdG8gYnV0IG5vdAogICAgICAgICAgICAgICAgICBpbmNsdWRpbmcgdGhlIGZpcnN0IGRvdCAoJy4nKS4gQW1vbmcgb3RoZXIgdGhpbmdzLCB0aGlzIG1lYW5zIHRoYXQKICAgICAgICAgICAgICAgICAgV2luZG93cyBwcm9ncmFtcyBydW5uaW5nIHVuZGVyIFdpbmUgY2Fubm90IGNoYW5nZSB0aGUgTmV0QklPUyBjb21wdXRlciBuYW1lLgogICAgICAgICAgICAgICAgPC9wYXJhPgogICAgICAgICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgICAgICAgIElmIHRoaXMgb3B0aW9uIGlzIHNldCB0byAiTiIsIFdpbmUgd2lsbCB1c2UgdGhlIHJlZ2lzdHJ5IHZhbHVlIGFib3ZlCiAgICAgICAgICAgICAgICAgIHRvIHNldCB0aGUgTmV0QklPUyBuYW1lLiBPbmx5IGlmIHRoZSByZWdpc3RyeSBlbnRyeSBkb2Vzbid0IGV4aXN0ICh1c3VhbGx5CiAgICAgICAgICAgICAgICAgIG9ubHkgZHVyaW5nIHRoZSBmaXJzdCB3aW5lIHN0YXJ0dXApIGl0IHdpbGwgdXNlIHRoZSBVbml4IGhvc3RuYW1lIGFzCiAgICAgICAgICAgICAgICAgIHVzdWFsLiBXaW5kb3dzIHByb2dyYW1zIGNhbiBjaGFuZ2UgdGhlIE5ldEJJT1MgbmFtZS4gVGhlIGNoYW5nZQogICAgICAgICAgICAgICAgICB3aWxsIGJlIGVmZmVjdGl2ZSBhZnRlciBhICJyZWJvb3QiLCBpLmUuIGFmdGVyIHJlc3RhcnRpbmcgV2luZS4KICAgICAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgICAgICA8L2xpc3RpdGVtPgogICAgICAgICAgICA8L3Zhcmxpc3RlbnRyeT4KICAgICAgICAgIDwvdmFyaWFibGVsaXN0PgogICAgICAgIDwvc2VjdDM+CgogICAgICAgIDxzZWN0MyBpZD0iY29uZmlnLWFwcGRlZmF1bHRzIj4KICAgICAgICAgIDx0aXRsZT5UaGUgW0FwcERlZmF1bHRzXSBTZWN0aW9uPC90aXRsZT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICBUaGUgc2VjdGlvbiBpcyB1c2VkIHRvIG92ZXJ3cml0ZSBjZXJ0YWluIHNldHRpbmdzIG9mIHRoaXMgZmlsZSBmb3IgYQogICAgICAgICAgICBzcGVjaWFsIHByb2dyYW0gd2l0aCBkaWZmZXJlbnQgc2V0dGluZ3MuCiAgICAgICAgICAgIFtBcHBEZWZhdWx0c10gaXMgbm90IHRoZSByZWFsIG5hbWUgb2YgdGhlIHNlY3Rpb24uIFRoZSByZWFsIG5hbWUKICAgICAgICAgICAgY29uc2lzdHMgb2YgdGhlIGxlYWRpbmcgd29yZCBBcHBEZWZhdWx0cyBmb2xsb3dlZCBieSB0aGUgbmFtZQogICAgICAgICAgICBvZiB0aGUgZXhlY3V0YWJsZSB0aGUgc2VjdGlvbiBpcyB2YWxpZCBmb3IuCiAgCSAgICBUaGUgZW5kIG9mIHRoZSBzZWN0aW9uIG5hbWUgaXMgdGhlIG5hbWUgb2YgdGhlCiAgCSAgICBjb3JyZXNwb25kaW5nICJzdGFuZGFyZCIgc2VjdGlvbiBvZiB0aGUgY29uZmlndXJhdGlvbiBmaWxlCiAgCSAgICB0aGF0IHNob3VsZCBoYXZlIHNvbWUgb2YgaXRzIHNldHRpbmdzIG92ZXJ3cml0dGVuIHdpdGggdGhlCiAgCSAgICBwcm9ncmFtIHNwZWNpZmljIHNldHRpbmdzIHlvdSBkZWZpbmUuCiAgCSAgICBUaGUgdGhyZWUgcGFydHMgb2YgdGhlIHNlY3Rpb24gbmFtZSBhcmUgc2VwYXJhdGVkIGJ5IHR3byBiYWNrc2xhc2hlcy4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICBDdXJyZW50bHkgd2luZSBzdXBwb3J0cyBvdmVycmlkaW5nIHNlbGVjdGVkIHNldHRpbmdzIHdpdGhpbgogIAkgICAgdGhlIHNlY3Rpb25zIFtEbGxPdmVycmlkZXNdLCBbeDExZHJ2XSwgW3ZlcnNpb25dIGFuZCBbZHNvdW5kXSBvbmx5LgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIEhlcmUgaXMgYW4gZXhhbXBsZSB0aGF0IG92ZXJyaWRlcyB0aGUgbm9ybWFsIHNldHRpbmdzIGZvciBhCiAgICAgICAgICAgIHByb2dyYW06CiAgCSAgICA8cHJvZ3JhbWxpc3Rpbmc+Cjs7IGRlZmF1bHQgc2V0dGluZ3MKW3gxMWRydl0KIk1hbmFnZWQiID0gIlkiCiJEZXNrdG9wIiA9ICJOIgoKOzsgcnVuIGluc3RhbGwgaW4gZGVza3RvcCBtb2RlCltBcHBEZWZhdWx0c1xcaW5zdGFsbC5leGVcXHgxMWRydl0KIk1hbmFnZWQiID0gIk4iCiJEZXNrdG9wIiA9ICI4MDB4NjAwIgogIAkgICAgPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICA8L3NlY3QzPgogICAgICA8L3NlY3QyPgoKICAgICAgPHNlY3QyIGlkPSJjb25maWctdHJvdWJsZSI+CiAgICAgICAgPHRpdGxlPldoYXQgSWYgSXQgRG9lc24ndCBXb3JrPzwvdGl0bGU+CiAgICAgICAgPHBhcmE+CiAgICAgICAgICBUaGVyZSBpcyBhbHdheXMgYSBjaGFuY2UgdGhhdCB0aGluZ3Mgd2lsbCBnbyB3cm9uZy4gSWYgdGhlCiAgICAgICAgICB1bnRoaW5rYWJsZSBoYXBwZW5zLCByZXBvcnQgdGhlIHByb2JsZW0gdG8KICAJICA8dWxpbmsgdXJsPSJodHRwOi8vYnVncy53aW5laHEuY29tLyI+V2luZSBCdWd6aWxsYTwvdWxpbms+LAogIAkgIHRyeSB0aGUgbmV3c2dyb3VwCiAgICAgICAgICA8c3lzdGVtaXRlbT5jb21wLmVtdWxhdG9ycy5tcy13aW5kb3dzLndpbmU8L3N5c3RlbWl0ZW0+LAogIAkgIG9yIHRoZSBJUkMgY2hhbm5lbCA8c3lzdGVtaXRlbT4jV2luZUhRPC9zeXN0ZW1pdGVtPiBmb3VuZCBvbgogICAgICAgICAgaXJjLmZyZWVub2RlLm5ldCwgb3IgY29ubmVjdGVkIHNlcnZlcnMuCiAgCSAgTWFrZSBzdXJlIHRoYXQgeW91IGhhdmUgbG9va2VkIG92ZXIgdGhpcyBkb2N1bWVudCB0aG9yb3VnaGx5LAogIAkgIGFuZCBoYXZlIGFsc28gcmVhZDoKICAgICAgICA8L3BhcmE+CiAgICAgICAgPGl0ZW1pemVkbGlzdD4KICAgICAgICAgIDxsaXN0aXRlbT4KICAgICAgICAgICAgPHBhcmE+PGZpbGVuYW1lPlJFQURNRTwvZmlsZW5hbWU+PC9wYXJhPgogICAgICAgICAgPC9saXN0aXRlbT4KICAgICAgICAgIDxsaXN0aXRlbT4KICAgICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgICAgPGZpbGVuYW1lPmh0dHA6Ly93d3cud2luZWhxLm9yZy90cm91YmxlLzwvZmlsZW5hbWU+CiAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgICAgPC9pdGVtaXplZGxpc3Q+CiAgICAgICAgPHBhcmE+CiAgICAgICAgICBJZiBpbmRlZWQgaXQgbG9va3MgbGlrZSB5b3UndmUgZG9uZSB5b3VyIHJlc2VhcmNoLCBiZQogICAgICAgICAgcHJlcGFyZWQgZm9yIGhlbHBmdWwgc3VnZ2VzdGlvbnMuIElmIHlvdSBoYXZlbid0LCBicmFjZQogICAgICAgICAgeW91cnNlbGYgZm9yIGhlYXZpbmcgZmxhbWluZy4KICAgICAgICA8L3BhcmE+CiAgICAgIDwvc2VjdDI+CiAgICA8L3NlY3QxPgoKICAgIDxzZWN0MSBpZD0iY29uZmlnLWRyaXZlLW1haW4iPgogICAgICA8dGl0bGU+VGhlIFdpbmUgRmlsZSBTeXN0ZW0gQW5kIERyaXZlIExheWVyPC90aXRsZT4KICAgICAgPHNlY3QyPgogICAgICAgIDx0aXRsZT5FeHRyZW1lbHkgSW1wb3J0YW50IFByZXJlcXVpc2l0ZXM8L3RpdGxlPgoJPHBhcmE+CgkgIElmIHlvdSdyZSBwbGFubmluZyB0byBpbmNsdWRlIGFjY2VzcyB0byBhIENELVJPTSBkcml2ZSBpbiB5b3VyIFdpbmUKCSAgY29uZmlndXJhdGlvbiBvbiBMaW51eCwgdGhlbiA8ZW1waGFzaXM+bWFrZSBzdXJlPC9lbXBoYXNpcz4gdG8gYWRkCgkgIHRoZSA8cXVvdGU+dW5oaWRlPC9xdW90ZT4gbW91bnQgb3B0aW9uIHRvIHRoZSBDRC1ST00gZmlsZSBzeXN0ZW0KCSAgZW50cnkgaW4gPGZpbGVuYW1lPi9ldGMvZnN0YWI8L2ZpbGVuYW1lPiwgZS5nLjoKCSAgPHByb2dyYW1saXN0aW5nPgovZGV2L2Nkcm9tIC9jZHJvbSAgaXNvOTY2MCBybyxub2F1dG8sdXNlcnMsdW5oaWRlIDAgMAoJICA8L3Byb2dyYW1saXN0aW5nPgoJICBTZXZlcmFsIFdpbmRvd3MgcHJvZ3JhbSBzZXR1cCBDRC1ST01zIG9yIG90aGVyIENELVJPTXMgY2hvc2UKCSAgdG8gZG8gc3VjaCBicmFpbmRhbWFnZWQgdGhpbmdzIGFzIG1hcmtpbmcgdmVyeSBpbXBvcnRhbnQgc2V0dXAKCSAgaGVscGVyIGZpbGVzIG9uIHRoZSBDRC1ST00gYXMgPHF1b3RlPmhpZGRlbjwvcXVvdGU+LgoJICBUaGF0J3Mgbm8gcHJvYmxlbSBvbiBXaW5kb3dzLCBzaW5jZSB0aGUgV2luZG93cyBDRC1ST00gZHJpdmVyIGJ5CgkgIGRlZmF1bHQgZGlzcGxheXMgZXZlbiBmaWxlcyB0aGF0IGFyZSBzdXBwb3NlZCB0byBiZQoJICA8cXVvdGU+aGlkZGVuPC9xdW90ZT4uIEJ1dCBvbiBMaW51eCwgd2hpY2ggY2hvc2UgdG8KCSAgPGVtcGhhc2lzPmhpZGU8L2VtcGhhc2lzPiA8cXVvdGU+aGlkZGVuPC9xdW90ZT4gZmlsZXMgb24gQ0QgYnkKCSAgZGVmYXVsdCwgdGhpcyBpcyA8ZW1waGFzaXM+RkFUQUw8L2VtcGhhc2lzPiEKCSAgKHRoZSBwcm9ncmFtcyB3aWxsIHNpbXBseSBhYm9ydCB3aXRoIGFuIDxxdW90ZT5pbnN0YWxsYXRpb24gZmlsZSBub3QgZm91bmQ8L3F1b3RlPiBvciBzaW1pbGFyIGVycm9yKQoJICBUaHVzIHlvdSBzaG91bGQgbmV2ZXIgZm9yZ2V0IHRvIGFkZCB0aGlzIHNldHRpbmcuCgk8L3BhcmE+CiAgICAgIDwvc2VjdDI+CgogICAgICA8c2VjdDI+CiAgICAgICAgPHRpdGxlPlNob3J0IEludHJvZHVjdGlvbjwvdGl0bGU+CiAgICAgICAgPHBhcmE+CgkgIFdpbmUgZW11bGF0ZXMgZHJpdmVzIGJ5IHBsYWNpbmcgdGhlaXIgdmlydHVhbCBkcml2ZSByb290cyB0bwoJICB1c2VyLWNvbmZpZ3VyYWJsZSBwb2ludHMgaW4gdGhlIFVuaXggZmlsZXN5c3RlbSwgc28gaXQncyB5b3VyCgkgIGNob2ljZSB3aGVyZSA8bWVkaWFsYWJlbD5DOjwvbWVkaWFsYWJlbD4ncyByb290IHNob3VsZCBiZQoJICAoPGZpbGVuYW1lPnRvb2xzL3dpbmVpbnN0YWxsPC9maWxlbmFtZT4gd2lsbCBldmVuIGFzayB5b3UpLiBJZgoJICB5b3UgY2hvb3NlLCBzYXksIDxmaWxlbmFtZT5+L3dpbmU8L2ZpbGVuYW1lPiAob3IsIGluIG90aGVyCgkgIHdvcmRzLCA8ZmlsZW5hbWU+L2hvbWUvdXNlci93aW5lPC9maWxlbmFtZT4sIHNpbmNlICJ+IgoJICBpbmRpY2F0ZXMgdGhlIGhvbWUgZGlyZWN0b3J5IG9mIGEgdXNlciksIGFzIHRoZSByb290IG9mIHlvdXIKCSAgdmlydHVhbCBkcml2ZSA8bWVkaWFsYWJlbD5DOjwvbWVkaWFsYWJlbD4sIHRoZW4geW91J2QgcHV0IHRoaXMKCSAgaW50byB5b3VyIFdpbmUgY29uZmlndXJhdGlvbiBmaWxlOgogICAgICAgIDwvcGFyYT4KCiAgICAgICAgPHByb2dyYW1saXN0aW5nPgpbRHJpdmUgQ10KIlBhdGgiID0gIiR7SE9NRX0vd2luZSIKIlR5cGUiID0gImhkIgoiTGFiZWwiID0gIk1TLURPUyIKIkZpbGVzeXN0ZW0iID0gIndpbjk1IgogICAgICAgIDwvcHJvZ3JhbWxpc3Rpbmc+CgogICAgICAgIDxwYXJhPgogICAgICAgICAgV2l0aCB0aGlzIGNvbmZpZ3VyYXRpb24sIHdoYXQgd2luZG93cyBhcHBzIHRoaW5rIG9mIGFzCiAgICAgICAgICAiYzpcd2luZG93c1xzeXN0ZW0iIHdvdWxkIG1hcCB0bwogICAgICAgICAgPGZpbGVuYW1lPi9ob21lL3VzZXIvd2luZS93aW5kb3dzL3N5c3RlbTwvZmlsZW5hbWU+IGluIHRoZSBVTklYCiAgICAgICAgICBmaWxlc3lzdGVtLiBOb3RlIHRoYXQgeW91IG5lZWQgdG8gc3BlY2lmeQogICAgICAgICAgPGxpdGVyYWw+IkZpbGVzeXN0ZW0iID0gIndpbjk1IjwvbGl0ZXJhbD4sCgkgIDxlbXBoYXNpcz5ub3Q8L2VtcGhhc2lzPgogICAgICAgICAgPGxpdGVyYWw+IkZpbGVzeXN0ZW0iID0gInVuaXgiPC9saXRlcmFsPiwgdG8gbWFrZSBXaW5lIHNpbXVsYXRlIGEKICAgICAgICAgIFdpbmRvd3MgY29tcGF0aWJsZSAoY2FzZSBpbnNlbnNpdGl2ZSkgZmlsZXN5c3RlbSwgb3RoZXJ3aXNlCiAgICAgICAgICBtb3N0IGFwcHMgd29uJ3Qgd29yay4KICAgICAgICA8L3BhcmE+CiAgICAgIDwvc2VjdDI+CgogICAgICA8c2VjdDIgaWQ9ImNvbmZpZy1kcml2ZS1kaXIiPgogICAgICAgIDx0aXRsZT5XaW5kb3dzIERpcmVjdG9yeSBTdHJ1Y3R1cmU8L3RpdGxlPgogICAgICAgIDxwYXJhPgoJICBIZXJlJ3MgdGhlIGZ1bmRhbWVudGFsIGxheW91dCB0aGF0IFdpbmRvd3MgcHJvZ3JhbXMgYW5kCgkgIGluc3RhbGxlcnMgZXhwZWN0IGFuZCB0aGF0IHdlIHRodXMgbmVlZCB0byBjb25maWd1cmUgcHJvcGVybHkKCSAgaW4gV2luZS4gV2l0aG91dCBpdCwgdGhleSBzZWxkb21seSBvcGVyYXRlIGNvcnJlY3RseS4gIElmIHlvdQoJICBpbnRlbmQgdG8gdXNlIGEgbm8td2luZG93cyBlbnZpcm9ubWVudCAobm90IHVzaW5nIGFuIGV4aXN0aW5nCgkgIFdpbmRvd3MgcGFydGl0aW9uKSwgdGhlbiBpdCBpcyByZWNvbW1lbmRlZCB0byB1c2UgZWl0aGVyCgkgIDxjb21tYW5kPldpbmVTZXR1cFRrPC9jb21tYW5kPidzIG9yCgkgIDxjb21tYW5kPndpbmVpbnN0YWxsPC9jb21tYW5kPidzIGNhcGFiaWxpdGllcyB0byBjcmVhdGUgYW4KCSAgaW5pdGlhbCB3aW5kb3dzIGRpcmVjdG9yeSB0cmVlLCBzaW5jZSBjcmVhdGluZyBhIGRpcmVjdG9yeQoJICBzdHJ1Y3R1cmUgbWFudWFsbHkgaXMgdGlyZXNvbWUgYW5kIGVycm9yLXByb25lLgogICAgICAgIDwvcGFyYT4KCjxwcm9ncmFtbGlzdGluZz4KQzpcICAgICAgICAgICAgICAgIFJvb3QgZGlyZWN0b3J5IG9mIHByaW1hcnkgZGlzayBkcml2ZQogIFdpbmRvd3NcICAgICAgICAgV2luZG93cyBkaXJlY3RvcnksIGNvbnRhaW5pbmcgLklOSSBmaWxlcywKICAgICAgICAgICAgICAgICAgICAgYWNjZXNzb3JpZXMsIGV0Yy4KICAgIFN5c3RlbVwgICAgICAgIFdpbjMueC85NS85OC9NRSBkaXJlY3RvcnkgZm9yIGNvbW1vbiBETExzCiAgICAgICAgICAgICAgICAgICAgIFdpbk5ULzIwMDAgZGlyZWN0b3J5IGZvciBjb21tb24gMTYtYml0IERMTHMKICAgIFN5c3RlbTMyXCAgICAgIFdpbk5ULzIwMDAgZGlyZWN0b3J5IGZvciBjb21tb24gMzItYml0IERMTHMKICAgIFN0YXJ0IE1lbnVcICAgIFByb2dyYW0gbGF1bmNoZXIgZGlyZWN0b3J5IHN0cnVjdHVyZQogICAgICBQcm9ncmFtc1wgICAgUHJvZ3JhbSBsYXVuY2hlciBsaW5rcyAoLkxOSyBmaWxlcykgdG8gcHJvZ3JhbXMKICBQcm9ncmFtIEZpbGVzXCAgIEFwcGxpY2F0aW9uIGJpbmFyaWVzICguRVhFIGFuZCAuRExMIGZpbGVzKQo8L3Byb2dyYW1saXN0aW5nPgogICAgICA8L3NlY3QyPgoKICAgICAgPHNlY3QyIGlkPSJjb25maWctZHJpdmUtc2VjdGlvbnMiPgogICAgICAgIDx0aXRsZT5UaGUgW0RyaXZlIHhdIFNlY3Rpb25zPC90aXRsZT4KICAgICAgICA8cGFyYT4KICAgICAgICAgICAgVGhlc2Ugc2VjdGlvbnMgYXJlIHN1cHBvc2VkIHRvIG1ha2UgY2VydGFpbiBVbml4CiAgICAgICAgICAgIGRpcmVjdG9yeSBsb2NhdGlvbnMgYWNjZXNzaWJsZSB0byBXaW5lIGFzIGEgRE9TL1dpbmRvd3MgZHJpdmUKICAgICAgICAgICAgKGRyaXZlICd4OicpIGFuZCB0aHVzIGFjY2Vzc2libGUgdG8gV2luZG93cyBwcm9ncmFtcwogICAgICAgICAgICB1bmRlciB0aGUgZHJpdmUgbmFtZSB5b3Ugc3BlY2lmaWVkLgoJICAgIEV2ZXJ5IERPUy9XaW5kb3dzIHByb2dyYW0gc29ydCBvZiBleHBlY3RzIGF0IGxlYXN0IGEgQzoKCSAgICBkcml2ZSAoYW5kIHNvbWV0aW1lcyBhbHNvIGFuIEE6IGZsb3BweSBkcml2ZSksIHNvIHlvdXIKCSAgICBjb25maWd1cmF0aW9uIGZpbGUgc2hvdWxkIGF0IGxlYXN0IGNvbnRhaW4gdGhlIGNvcnJlc3BvbmRpbmcKCSAgICBzZWN0aW9ucywgW0RyaXZlIENdIGFuZCBbRHJpdmUgQV0uCiAgICAgICAgICAgIFlvdSBuZWVkIHRvIGRlY2lkZSBvbiB3aGV0aGVyIHlvdSB3YW50IHRvIHVzZSBhbiBleGlzdGluZyBXaW5kb3dzCiAgICAgICAgICAgIHBhcnRpdGlvbiBhcyB0aGUgQyBkcml2ZSBvciB3aGV0aGVyIHlvdSB3YW50IHRvIGNyZWF0ZSB5b3VyIG93bgogICAgICAgICAgICBXaW5lIGRyaXZlIEMgZGlyZWN0b3J5IHRyZWUgc29tZXdoZXJlICh0YWtlIGNhcmUgYWJvdXQKICAgICAgICAgICAgcGVybWlzc2lvbnMhKS4KICAgICAgICAgICAgRWFjaCBkcml2ZSBzZWN0aW9uIG1heSBzcGVjaWZ5IHVwIHRvIDYgZGlmZmVyZW50IHNldHRpbmdzCiAgICAgICAgICAgIGFzIGV4cGxhaW5lZCBiZWxvdy4KICAgICAgICA8L3BhcmE+CiAgICAgICAgPHBhcmE+CiAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+W0RyaXZlIHhdPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgIFRoZSBhYm92ZSBsaW5lIGJlZ2lucyB0aGUgc2VjdGlvbiBmb3IgYSBkcml2ZSB3aG9zZSBsZXR0ZXIgaXMgeAogICAgICAgICAgICAoRE9TIG5vdGF0aW9uOiBkcml2ZSAneDonKS4KICAgICAgICAgICAgWW91IGNvdWxkIGUuZy4gY3JlYXRlIGFuIGVxdWl2YWxlbnQgdG8gYSBkcml2ZSAnQzonCiAgICAgICAgICAgIHVuZGVyIERPUy9XaW5kb3dzIGJ5IHVzaW5nIGEgW0RyaXZlIENdIHNlY3Rpb24gbmFtZS4KCSAgICBOb3RlIHRoYXQgdGhlIGRyaXZlIGxldHRlciBpcyBjYXNlIGluc2Vuc2l0aXZlLgogICAgICAgIDwvcGFyYT4KICAgICAgICA8cGFyYT4KICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4iUGF0aCIgPSAiL2Rpci90by9wYXRoIjwvcHJvZ3JhbWxpc3Rpbmc+CiAgICAgICAgICAgIFRoaXMgc3BlY2lmaWVzIHRoZSBkaXJlY3Rvcnkgd2hlcmUgdGhlIGRyaXZlIHdpbGwgYmVnaW4uCiAgICAgICAgICAgIFdoZW4gV2luZSBpcyBicm93c2luZyBpbiBkcml2ZSB4LCBpdCB3aWxsIGJlIGFibGUKICAgICAgICAgICAgdG8gc2VlIHRoZSBmaWxlcyB0aGF0IGFyZSBpbiB0aGUgZGlyZWN0b3J5CiAgICAgICAgICAgIDxmaWxlbmFtZT4vZGlyL3RvL3BhdGg8L2ZpbGVuYW1lPiBhbmQgYmVsb3cuCiAgICAgICAgICAgIChub3RlIHRoYXQgc3ltbGlua3MgdG8gZGlyZWN0b3JpZXMgd29uJ3QgZ2V0IGluY2x1ZGVkIQogICAgICAgICAgICBzZWUgIjxsaW5rIGxpbmtlbmQ9ImRpcnN5bWxpbmtzIj5TaG93RGlyU3ltbGlua3M8L2xpbms+IgogICAgICAgICAgICBjb25maWd1cmF0aW9uIHNldHRpbmcpCiAgICAgICAgICAgIFlvdSBjYW4gYWxzbyBtYWtlIHVzZSBvZiBlbnZpcm9ubWVudCB2YXJpYWJsZXMgbGlrZSAkSE9NRSBoZXJlLAoJICAgIGFuIGV4YW1wbGUgZm9yIHVzaW5nIGEgPGZpbGVuYW1lPm15d2luZWRyaXZlPC9maWxlbmFtZT4KCSAgICBkaXJlY3RvcnkgaW4geW91ciBob21lIGRpciB3b3VsZCBiZQogICAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+IlBhdGgiID0gIiR7SE9NRX0vbXl3aW5lZHJpdmUiPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgICAgRG9uJ3QgZm9yZ2V0IHRvIGxlYXZlIG9mZiB0aGUgdHJhaWxpbmcgc2xhc2ghCiAgICAgICAgPC9wYXJhPgogICAgICAgIDxwYXJhPgogICAgICAgICAgPHByb2dyYW1saXN0aW5nPiJUeXBlIiA9ICJoZHxjZHJvbXxuZXR3b3JrfGZsb3BweSI8L3Byb2dyYW1saXN0aW5nPgogICAgICAgICAgU2V0cyB1cCB0aGUgdHlwZSBvZiBkcml2ZSBXaW5lIHdpbGwgc2VlIGl0IGFzLiBUeXBlIG11c3QKICAgICAgICAgIGVxdWFsIG9uZSBvZiB0aGUgZm91ciA8bGl0ZXJhbD5mbG9wcHk8L2xpdGVyYWw+LAogICAgICAgICAgPGxpdGVyYWw+aGQ8L2xpdGVyYWw+LCA8bGl0ZXJhbD5jZHJvbTwvbGl0ZXJhbD4sIG9yCiAgICAgICAgICA8bGl0ZXJhbD5uZXR3b3JrPC9saXRlcmFsPi4gVGhleSBhcmUgc2VsZi1leHBsYW5hdG9yeS4KICAgICAgICAgIChUaGUgfCdzIG1lYW4gIlR5cGUgPSAnJmx0O29uZSBvZiB0aGUgb3B0aW9ucyZndDsnIi4pCiAgICAgICAgICBVc3VhbGx5LCB5b3UgY2hvb3NlICJoZCIgZm9yIGEgZHJpdmUgKCJoZCIgaXMgZGVmYXVsdCBhbnl3YXkpLgoJICBGb3IgYSBob21lIGRpcmVjdG9yeSBlbnRyeSwgaXQgbWFrZXMgc2Vuc2UgdG8gY2hvb3NlCgkgICJuZXR3b3JrIiBzb21ldGltZXMsIHNpbmNlIHNvbWUgaG9tZSBkaXJlY3RvcmllcyBhcmUgYmVpbmcKCSAgZXhwb3J0ZWQgb3ZlciB0aGUgbmV0d29yayB2aWEgTkZTIGFuZCB0aHVzIGNhbiBoYXZlIHNsb3cgcmVzcG9uc2UKCSAgdGltZXMuCiAgICAgICAgPC9wYXJhPgogICAgICAgIDxwYXJhPgogICAgICAgICAgPHByb2dyYW1saXN0aW5nPiJMYWJlbCIgPSAiYmxhaCI8L3Byb2dyYW1saXN0aW5nPgogICAgICAgICAgICBEZWZpbmVzIHRoZSBkcml2ZSBsYWJlbC4gR2VuZXJhbGx5IG9ubHkgbmVlZGVkCiAgICAgICAgICAgIGZvciBwcm9ncmFtcyB0aGF0IGxvb2sgZm9yIGEgc3BlY2lhbCBDRC1ST00uCiAgICAgICAgICBUaGUgbGFiZWwgbWF5IGJlIHVwIHRvIDExIGNoYXJhY3RlcnMuCiAgICAgICAgICAgIE5vdGUgdGhhdCB0aGUgcHJlZmVycmVkIHdheSBvZiBtYW5hZ2luZyBsYWJlbHMgYW5kIHNlcmlhbCBudW1iZXJzCiAgICAgICAgICAgIG9mIENELVJPTXMgYW5kIGZsb3BwaWVzIGlzIHRvIGdpdmUgV2luZSByYXcgZGV2aWNlIGFjY2VzcyBmb3IKICAgICAgICAgICAgcmVhZGluZyB0aGVzZSBvbiBhIHBlci1DRCBjYXNlIChzZWUgIkRldmljZSIgYmVsb3cpIGluc3RlYWQgb2YKICAgICAgICAgICAgaGFyZGNvZGluZyBvbmUgc3BlY2lmaWMgIkxhYmVsIi4KICAgICAgICA8L3BhcmE+CiAgICAgICAgPHBhcmE+CiAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+IlNlcmlhbCIgPSAiZGVhZGJlZWYiPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgIFRlbGxzIFdpbmUgdGhlIHNlcmlhbCBudW1iZXIgb2YgdGhlIGRyaXZlLiBBIGZldyBwcm9ncmFtcyB3aXRoCiAgICAgICAgICBpbnRlbnNlIHByb3RlY3Rpb24gZm9yIHBpcmF0aW5nIG1pZ2h0IG5lZWQgdGhpcywgYnV0IG90aGVyd2lzZQogICAgICAgICAgaXQncyBub3QgbmVlZGVkLiBVcCB0byA4IGNoYXJhY3RlcnMgYW5kIGhleGFkZWNpbWFsLgogICAgICAgICAgICBVc2luZyBhICJEZXZpY2UiIGVudHJ5IGluc3RlYWQgb2YgaGFyZGNvZGluZyB0aGUgIlNlcmlhbCIgcHJvYmFibHkKICAgICAgICAgICAgaXMgYSBzbWFydGVyIGNob2ljZS4KICAgICAgICA8L3BhcmE+CiAgICAgICAgPHBhcmE+CiAgICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+IkZpbGVzeXN0ZW0iID0gIndpbjk1fHVuaXh8bXNkb3MiPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgIFNldHMgdXAgdGhlIHdheSBXaW5lIGxvb2tzIGF0IGZpbGVzIG9uIHRoZSBkcml2ZS4KICAgICAgICAgIFRoaXMgc2V0dGluZyBjb250cm9scyB0aGUgZmlsZSBuYW1lIGxvb2t1cCBhbmQgbWFwcGluZyBvZgogICAgICAgICAgV2luZSB0byBleGlzdGluZyBmaWxlIHN5c3RlbXMgb24geW91ciBQQywgaXQgZG9lcwogICAgICAgICAgPGVtcGhhc2lzPm5vdDwvZW1waGFzaXM+IHRlbGwgYW55dGhpbmcgYWJvdXQgdGhlIGZpbGVzeXN0ZW0KICAgICAgICAgIHVzZWQgaXRzZWxmLgogICAgICAgIDwvcGFyYT4KCiAgICAgICAgPHZhcmlhYmxlbGlzdD4KICAgICAgICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgICAgICAgIDx0ZXJtPjxsaXRlcmFsPndpbjk1PC9saXRlcmFsPjwvdGVybT4KICAgICAgICAgICAgPGxpc3RpdGVtPgogICAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgICAgQ2FzZSBpbnNlbnNpdGl2ZS4gQWxpa2UgdG8gV2luZG93cyA5eC9OVCA0LiBUaGlzIGlzCiAgICAgICAgICAgICAgICB0aGUgbG9uZyBmaWxlbmFtZSBmaWxlc3lzdGVtIHlvdSBhcmUgcHJvYmFibHkgdXNlZAogICAgICAgICAgICAgICAgdG8gd29ya2luZyB3aXRoLiBUaGUgZmlsZXN5c3RlbSBi5mhhdmlvdXIgb2YgY2hvaWNlIGZvciBtb3N0CiAgICAgICAgICAgICAgICBwcm9ncmFtcyB0byBiZSBydW4gdW5kZXIgd2luZS4gIDxlbXBoYXNpcz5Qcm9iYWJseSB0aGUgb25lCiAgICAgICAgICAgICAgICB5b3Ugd2FudCE8L2VtcGhhc2lzPgogICAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgICAgPC9saXN0aXRlbT4KICAgICAgICAgIDwvdmFybGlzdGVudHJ5PgogICAgICAgICAgPHZhcmxpc3RlbnRyeT4KICAgICAgICAgICAgPHRlcm0+PGxpdGVyYWw+dW5peDwvbGl0ZXJhbD48L3Rlcm0+CiAgICAgICAgICAgIDxsaXN0aXRlbT4KICAgICAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgICAgIENhc2Ugc2Vuc2l0aXZlLiBUaGlzIGZpbGVzeXN0ZW0gaGFzIGFsbW9zdCBubyB1c2UKICAgICAgICAgICAgICAgIChXaW5kb3dzIGFwcHMgZXhwZWN0IGNhc2UgaW5zZW5zaXRpdmUgZmlsZW5hbWVzKSwKICAgICAgICAJICBleGNlcHQgbWF5YmUgZm9yIFdpbmVsaWIgYXBwbGljYXRpb25zLgogICAgICAgICAgICAgICAgVHJ5IGl0IGlmIHlvdSBkYXJlLCBidXQgd2luOTUgaXMgYSBtdWNoIGJldHRlcgogICAgICAgICAgICAgICAgYW5kIGFsd2F5cyByZWNvbW1lbmRlZCBjaG9pY2UuCiAgICAgICAgICAgICAgPC9wYXJhPgogICAgICAgICAgICA8L2xpc3RpdGVtPgogICAgICAgICAgPC92YXJsaXN0ZW50cnk+CiAgICAgICAgICA8dmFybGlzdGVudHJ5PgogICAgICAgICAgICA8dGVybT48bGl0ZXJhbD5tc2RvczwvbGl0ZXJhbD48L3Rlcm0+CiAgICAgICAgICAgIDxsaXN0aXRlbT4KICAgICAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgICAgIENhc2UgaW5zZW5zaXRpdmUgZmlsZXN5c3RlbS4gQWxpa2UgdG8gRE9TIGFuZAogICAgICAgICAgICAgICAgV2luZG93cyAzLnguIDxsaXRlcmFsPjguMzwvbGl0ZXJhbD4gaXMgdGhlIG1heGltdW0KICAgICAgICAgICAgICAgIGxlbmd0aCBvZiBmaWxlcyAoZWlnaHRkb3QuMTIzKSAtIGxvbmdlciBvbmVzIHdpbGwgYmUKICAgICAgICAgICAgICAgIHRydW5jYXRlZC4KICAgICAgICAJICA8bm90ZT4KICAgICAgICAJICA8cGFyYT4KICAgICAgICAJICAgIFRoaXMgaXMgYSA8ZW1waGFzaXM+dmVyeSBiYWQgY2hvaWNlPC9lbXBoYXNpcz4gaWYKICAgICAgICAJICAgIHlvdSBwbGFuIG9uIHJ1bm5pbmcgYXBwcyB0aGF0IHVzZSBsb25nIGZpbGVuYW1lcy4KICAgICAgICAJICAgIHdpbjk1IHNob3VsZCB3b3JrIGZpbmUgd2l0aCBhcHBzIHRoYXQgd2VyZSBkZXNpZ25lZAogICAgICAgIAkgICAgdG8gcnVuIHVuZGVyIHRoZSBtc2RvcyBzeXN0ZW0uICBJbiBvdGhlciB3b3JkcywgeW91CiAgICAgICAgCSAgICBtaWdodCBub3Qgd2FudCB0byB1c2UgdGhpcy4KICAgICAgICAJICA8L3BhcmE+CiAgICAgICAgCSAgPC9ub3RlPgogICAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgICAgPC9saXN0aXRlbT4KICAgICAgICAgIDwvdmFybGlzdGVudHJ5PgogICAgICAgIDwvdmFyaWFibGVsaXN0PgoKICAgICAgICA8cHJvZ3JhbWxpc3Rpbmc+IkRldmljZSIgPSAiL2Rldi94eCI8L3Byb2dyYW1saXN0aW5nPgogICAgICAgIDxwYXJhPgogICAgICAgICAgTmVlZGVkIGZvciByYXcgZGV2aWNlIGFjY2VzcyBhbmQgPGxpbmsgbGlua2VuZD0iY29uZmlnLWRyaXZlLWNkcm9tLWxhYmVscyI+bGFiZWwgYW5kIHNlcmlhbCBudW1iZXIgcmVhZGluZzwvbGluaz4uCiAgICAgICAgICBVc2UgdGhpcyA8ZW1waGFzaXM+b25seTwvZW1waGFzaXM+IGZvciBmbG9wcHkgYW5kIGNkcm9tIGRldmljZXMuIFVzaW5nIGl0IG9uCiAgICAgICAgICBFeHRlbmRlZDIgb3Igb3RoZXIgVW5peCBmaWxlIHN5c3RlbXMgY2FuIGhhdmUgZGlyZSByZXN1bHRzCiAgICAgICAgICAod2hlbiBhIHdpbmRvd3MgYXBwIHRyaWVzIHRvIGRvIGEgbG93bGV2ZWwgd3JpdGUsCiAgICAgICAgICB0aGV5IGRvIGl0IGluIGEgRkFUIHdheSAtLSBGQVQgZm9ybWF0IGlzIGNvbXBsZXRlbHkgZGlmZmVyZW50IGZyb20KICAgICAgICAgIGFueSBVbml4IGZpbGUgc3lzdGVtKS4KICAgICAgICAgIEFsc28sIG1ha2Ugc3VyZSB0aGF0IHlvdSBoYXZlIHByb3BlciBwZXJtaXNzaW9ucyB0byB0aGlzIGRldmljZQogICAgICAgICAgZmlsZS4KICAgICAgICA8L3BhcmE+CiAgICAgICAgPG5vdGU+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgVGhpcyBzZXR0aW5nIGlzIG5vdCByZWFsbHkgaW1wb3J0YW50OyBhbG1vc3QgYWxsIGFwcHMKICAgICAgICAgICAgd2lsbCBoYXZlIG5vIHByb2JsZW0gaWYgaXQgcmVtYWlucyB1bnNwZWNpZmllZC4gRm9yCiAgICAgICAgICAgIENELVJPTXMgaXQncyBxdWl0ZSB1c2VmdWwgaW4gb3JkZXIgdG8gZ2V0IGF1dG9tYXRpYyBsYWJlbAogICAgICAgICAgICBkZXRlY3Rpb24sIHRob3VnaC4gSWYgeW91IGFyZSB1bnN1cmUgYWJvdXQgc3BlY2lmeWluZwogICAgICAgICAgICBkZXZpY2UgbmFtZXMsIGp1c3QgbGVhdmUgb3V0IHRoaXMgc2V0dGluZyBmb3IgeW91cgogICAgICAgICAgICBkcml2ZXMuCiAgICAgICAgICA8L3BhcmE+CiAgICAgICAgPC9ub3RlPgogICAgICAgIDxwYXJhPgogICAgICAgICAgICBIZXJlIGFyZSBhIGZldyBzYW1wbGUgZW50cmllczoKICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4KSGVyZSBpcyBhIHNldHVwIGZvciBEcml2ZSBDLCBhIGdlbmVyaWMgaGFyZCBkcml2ZToKW0RyaXZlIENdCiJQYXRoIiA9ICIvZG9zYyIKIlR5cGUiID0gImhkIgoiTGFiZWwiID0gIkhhcmQgRHJpdmUiCiJGaWxlc3lzdGVtIiA9ICJ3aW45NSIKVGhpcyBpcyBhIHNldHVwIGZvciBEcml2ZSBFLCBhIGdlbmVyaWMgQ0QtUk9NIGRyaXZlOgpbRHJpdmUgRV0KIlBhdGgiID0gIi9tbnQvY2Ryb20iCiJUeXBlIiA9ICJjZHJvbSIKIkxhYmVsIiA9ICJUb3RhbCBBbm5paGlsYXRpb24iCiJGaWxlc3lzdGVtIiA9ICJ3aW45NSIKIkRldmljZSIgPSAiL2Rldi9jZHJvbSIKQW5kIGhlcmUgaXMgYSBzZXR1cCBmb3IgRHJpdmUgQSwgYSBnZW5lcmljIGZsb3BweSBkcml2ZToKW0RyaXZlIEFdCiJUeXBlIiA9ICJmbG9wcHkiCiJQYXRoIiA9ICIvbW50L2Zsb3BweSIKIkxhYmVsIiA9ICJGbG9wcHkgRHJpdmUiCiJTZXJpYWwiID0gIjg3NjU0MzIxIgoiRmlsZXN5c3RlbSIgPSAid2luOTUiCiJEZXZpY2UiID0gIi9kZXYvZmQwIgogICAgICAgICAgPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICA8L3BhcmE+CiAgICAgIDwvc2VjdDI+CgogICAgICA8c2VjdDI+CiAgICAgICAgICA8dGl0bGU+RmlsZSBzeXN0ZW0gc2V0dGluZ3MgaW4gdGhlIFt3aW5lXSBzZWN0aW9uPC90aXRsZT4KICAgICAgICA8cGFyYT4KICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4iV2luZG93cyIgPSAiYzpcXHdpbmRvd3MiPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgIFRoaXMgdGVsbHMgV2luZSBhbmQgV2luZG93cyBwcm9ncmFtcyB3aGVyZSB0aGUKICAgICAgICAgIDxmaWxlbmFtZT5XaW5kb3dzPC9maWxlbmFtZT4gZGlyZWN0b3J5IGlzLiAgSXQgaXMKICAgICAgICAgIHJlY29tbWVuZGVkIHRvIGhhdmUgdGhpcyBkaXJlY3Rvcnkgc29tZXdoZXJlIG9uIHlvdXIKICAgICAgICAgIGNvbmZpZ3VyZWQgPG1lZGlhbGFiZWw+QzwvbWVkaWFsYWJlbD4gZHJpdmUsIGFuZCBpdCdzIGFsc28KICAgICAgICAgIHJlY29tbWVuZGVkIHRvIGp1c3QgY2FsbCB0aGUgZGlyZWN0b3J5ICJ3aW5kb3dzIiAodGhpcyBpcwogICAgICAgICAgdGhlIGRlZmF1bHQgc2V0dXAgb24gV2luZG93cywgYW5kIHNvbWUgc3R1cGlkIHByb2dyYW1zCiAgICAgICAgICBtaWdodCByZWx5IG9uIHRoaXMpLiAgU28gaW4gY2FzZSB5b3UgY2hvc2UgYSAiV2luZG93cyIKICAgICAgICAgIHNldHRpbmcgb2YgImM6XFx3aW5kb3dzIiBhbmQgeW91IGNob3NlIHRvIHNldCB1cCBhIGRyaXZlIEMKICAgICAgICAgIGUuZy4gYXQgPGZpbGVuYW1lPi91c3IvbG9jYWwvd2luZV9jPC9maWxlbmFtZT4sIHRoZQogICAgICAgICAgY29ycmVzcG9uZGluZyBkaXJlY3Rvcnkgd291bGQgYmUKICAgICAgICAgIDxmaWxlbmFtZT4vdXNyL2xvY2FsL3dpbmVfYy93aW5kb3dzPC9maWxlbmFtZT4uICBNYWtlIG9uZQogICAgICAgICAgaWYgeW91IGRvbid0IGFscmVhZHkgaGF2ZSBvbmUuIDxlbXBoYXNpcz5ObyB0cmFpbGluZyBzbGFzaDwvZW1waGFzaXM+ICg8ZW1waGFzaXM+bm90PC9lbXBoYXNpcz4KICAgICAgICAgIDxmaWxlbmFtZT5DOlxcd2luZG93c1w8L2ZpbGVuYW1lPikhIFdyaXRlIGFjY2VzcyBzdHJvbmdseQogICAgICAgICAgcmVjb21tZW5kZWQsIGFzIFdpbmRvd3MgcHJvZ3JhbXMgYWx3YXlzIGFzc3VtZSB3cml0ZSBhY2Nlc3MKICAgICAgICAgICAgdG8gdGhlIFdpbmRvd3MgZGlyZWN0b3J5IQogICAgICAgIDwvcGFyYT4KICAgICAgICA8cGFyYT4KICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4iU3lzdGVtIiA9ICJjOlxcd2luZG93c1xcc3lzdGVtIjwvcHJvZ3JhbWxpc3Rpbmc+CiAgICAgICAgICBUaGlzIHNldHMgdXAgd2hlcmUgdGhlIHdpbmRvd3Mgc3lzdGVtIGZpbGVzIGFyZS4gVGhlIFdpbmRvd3MKICAgICAgICAgICAgc3lzdGVtIGRpcmVjdG9yeSBzaG91bGQgcmVzaWRlIGJlbG93IHRoZSBkaXJlY3RvcnkgdXNlZCBmb3IgdGhlCiAgICAgICAgICA8bGl0ZXJhbD5XaW5kb3dzPC9saXRlcmFsPiBzZXR0aW5nLgogICAgICAgICAgICBUaHVzIHdoZW4gdXNpbmcgdGhlIGV4YW1wbGUgYWJvdmUsIHRoZSBzeXN0ZW0gZGlyZWN0b3J5IHdvdWxkIGJlCiAgICAgICAgICAgIDxmaWxlbmFtZT4vdXNyL2xvY2FsL3dpbmVfYy93aW5kb3dzL3N5c3RlbTwvZmlsZW5hbWU+LgogICAgICAgICAgQWdhaW4sIG5vIHRyYWlsaW5nIHNsYXNoLCBhbmQgd3JpdGUgYWNjZXNzIQogICAgICAgIDwvcGFyYT4KICAgICAgICA8cGFyYT4KICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4iVGVtcCIgPSAiYzpcXHRlbXAiPC9wcm9ncmFtbGlzdGluZz4gVGhpcyBzaG91bGQKICAgICAgICAgIGJlIHRoZSBkaXJlY3RvcnkgeW91IHdhbnQgeW91ciB0ZW1wIGZpbGVzIHN0b3JlZCBpbiwKICAgICAgICAgICAgL3Vzci9sb2NhbC93aW5lX2MvdGVtcCBpbiBvdXIgZXhhbXBsZS4KICAgICAgICAgIEFnYWluLCBubyB0cmFpbGluZyBzbGFzaCwgYW5kIDxlbXBoYXNpcz53cml0ZQogICAgICAgICAgICBhY2Nlc3M8L2VtcGhhc2lzPiEhCiAgICAgICAgPC9wYXJhPgogICAgICAgIDxwYXJhPgogICAgICAgICAgPHByb2dyYW1saXN0aW5nPgoiUGF0aCIgPSAiYzpcXHdpbmRvd3M7YzpcXHdpbmRvd3NcXHN5c3RlbTtjOlxcYmxhbmNvIgogICAgICAgICAgPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICA8L3BhcmE+CiAgICAgICAgPHBhcmE+CiAgICAgICAgICBCZWhhdmVzIGxpa2UgdGhlIDxlbnZhcj5QQVRIPC9lbnZhcj4gc2V0dGluZyBvbiBVTklYCiAgICAgICAgICBib3hlcy4gV2hlbiB3aW5lIGlzIHJ1biBsaWtlIDx1c2VyaW5wdXQ+d2luZQogICAgICAgICAgICBzb2wuZXhlPC91c2VyaW5wdXQ+LCBpZiA8ZmlsZW5hbWU+c29sLmV4ZTwvZmlsZW5hbWU+CiAgICAgICAgICByZXNpZGVzIGluIGEgZGlyZWN0b3J5IHNwZWNpZmllZCBpbiB0aGUKICAgICAgICAgIDxsaXRlcmFsPlBhdGg8L2xpdGVyYWw+IHNldHRpbmcsIHdpbmUgd2lsbCBydW4gaXQgKE9mCiAgICAgICAgICBjb3Vyc2UsIGlmIDxmaWxlbmFtZT5zb2wuZXhlPC9maWxlbmFtZT4gcmVzaWRlcyBpbiB0aGUKICAgICAgICAgIGN1cnJlbnQgZGlyZWN0b3J5LCB3aW5lIHdpbGwgcnVuIHRoYXQgb25lKS4gTWFrZSBzdXJlIGl0CiAgICAgICAgICBhbHdheXMgaGFzIHlvdXIgPGZpbGVuYW1lPndpbmRvd3M8L2ZpbGVuYW1lPiBkaXJlY3RvcnkgYW5kCiAgICAgICAgICBzeXN0ZW0gZGlyZWN0b3J5IChGb3IgdGhpcyBzZXR1cCwgaXQgbXVzdCBoYXZlCiAgICAgICAgICA8ZmlsZW5hbWU+ImM6XFx3aW5kb3dzO2M6XFx3aW5kb3dzXFxzeXN0ZW0iPC9maWxlbmFtZT4pLgogICAgICAgIDwvcGFyYT4KICAgICAgICA8cGFyYSBpZD0iZGlyc3ltbGlua3MiPgogICAgICAgICAgPHByb2dyYW1saXN0aW5nPgoiU2hvd0RpclN5bWxpbmtzIiA9ICIxIgogICAgICAgICAgPC9wcm9ncmFtbGlzdGluZz4KICAgICAgICAgIFdpbmUgZG9lc24ndCBwYXNzIGRpcmVjdG9yeSBzeW1saW5rcyB0byBXaW5kb3dzIHByb2dyYW1zIGJ5CiAgICAgICAgICBkZWZhdWx0LCBhcyBkb2luZyBzbyBtYXkgY3Jhc2ggc29tZSBwcm9ncmFtcyB0aGF0IGRvCiAgICAgICAgICByZWN1cnNpdmUgbG9va3VwcyBvZiB3aG9sZSBzdWJkaXJlY3RvcnkgdHJlZXMKICAgICAgICAgIHdoZW5ldmVyIGEgZGlyZWN0b3J5IHN5bWxpbmsgcG9pbnRzIGJhY2sgdG8gaXRzZWxmIG9yIG9uZSBvZiBpdHMKICAgICAgICAgIHBhcmVudCBkaXJlY3Rvcmllcy4KICAgICAgICAgIFRoYXQncyB3aHkgd2UgZGlzYWxsb3dlZCB0aGUgdXNlIG9mIGRpcmVjdG9yeSBzeW1saW5rcwogICAgICAgICAgYW5kIGFkZGVkIHRoaXMgc2V0dGluZyB0byByZWVuYWJsZSAoIjEiKSB0aGlzIGZ1bmN0aW9uYWxpdHkuCgkgIElmIHlvdSA8ZW1waGFzaXM+cmVhbGx5PC9lbXBoYXNpcz4gbmVlZCBXaW5lIHRvIHRha2UgaW50bwoJICBhY2NvdW50IHN5bWxpbmtlZCBkaXJlY3RvcmllcywgdGhlbiByZWVuYWJsZSBpdCwgYnV0CgkgIDxlbXBoYXNpcz5iZSBwcmVwYXJlZCBmb3IgY3Jhc2hlczwvZW1waGFzaXM+IGluIGNlcnRhaW4KCSAgV2luZG93cyBwcm9ncmFtcyB3aGVuIHVzaW5nIHRoZSBhYm92ZSBtZXRob2QhIChpbiBvdGhlciB3b3JkczoKCSAgZW5hYmxpbmcgaXQgaXMgY2VydGFpbmx5IG5vdCByZWNvbW1lbmRlZCkKICAgICAgICA8L3BhcmE+CiAgICAgIDwvc2VjdDI+CgogICAgICA8c2VjdDI+CiAgICAgICAgPHRpdGxlPk1vcmUgZGV0YWlsZWQgZXhwbGFuYXRpb24gYWJvdXQgZmlsZSBzeXN0ZW0gZGlmZmVyZW5jZXM8L3RpdGxlPgogICAgICAgIDxwYXJhPgoJICBXaW5kb3dzIHVzZXMgYSBkaWZmZXJlbnQgKGFuZCBpbmZlcmlvcikgd2F5IHRoYW4gVW5peCB0byBkZXNjcmliZSB0aGUKCSAgbG9jYXRpb24gb2YgZmlsZXMgaW4gYSBjb21wdXRlci4gVGh1cyBXaW5kb3dzIHByb2dyYW1zIGFsc28gZXhwZWN0CgkgIHRvIGZpbmQgdGhpcyBkaWZmZXJlbnQgd2F5IHN1cHBvcnRlZCBieSB0aGUgc3lzdGVtLgoJICBTaW5jZSB3ZSBpbnRlbmQgdG8gcnVuIFdpbmRvd3MgcHJvZ3JhbXMgb24KCSAgYSBVbml4IHN5c3RlbSwgd2UncmUgaW4gdHJvdWJsZSwgYXMgd2UgbmVlZCB0byB0cmFuc2xhdGUKCSAgYmV0d2VlbiB0aGVzZSBkaWZmZXJlbnQgZmlsZSBhY2Nlc3MgdGVjaG5pcXVlcy4KCTwvcGFyYT4KCTxwYXJhPgogICAgICAgICAgV2luZG93cyB1c2VzIGRyaXZlIGxldHRlcnMgdG8gZGVzY3JpYmUgZHJpdmVzIG9yCiAgICAgICAgICBhbnkgb3RoZXIgZm9ybSBvZiBzdG9yYWdlIG1lZGlhIGFuZCB0byBhY2Nlc3MgZmlsZXMgb24gdGhlbS4KCSAgRm9yIGV4YW1wbGUsIGNvbW1vbiBkcml2ZSBuYW1lcyBhcmUKCSAgPGZpbGVuYW1lPkM6PC9maWxlbmFtZT4gZm9yIHRoZSBtYWluIFdpbmRvd3Mgc3lzdGVtIHBhcnRpdGlvbgoJICBvbiB0aGUgZmlyc3QgaGFyZGRpc2sgYW5kIDxmaWxlbmFtZT5BOjwvZmlsZW5hbWU+IGZvciB0aGUKCSAgZmlyc3QgZmxvcHB5IGRyaXZlLgoJICBBbHNvLCBXaW5kb3dzIHVzZXMgPGZpbGVuYW1lPlw8L2ZpbGVuYW1lPiAoYmFja3NsYXNoKSBhcyB0aGUKCSAgZGlyZWN0b3J5IHNlcGFyYXRvciBzaWduLCB3aGVyZWFzIFVuaXggdXNlcwoJICA8ZmlsZW5hbWU+LzwvZmlsZW5hbWU+IChzbGFzaCkuCgkgIFRodXMsIGFuIGV4YW1wbGUgZG9jdW1lbnQgb24gdGhlIGZpcnN0IGRhdGEgcGFydGl0aW9uIGluCgkgIFdpbmRvd3MgbWlnaHQgYmUgYWNjZXNzZWQgYnkgdGhlIG5hbWUgb2YKCSAgPGZpbGVuYW1lPkQ6XG15d29ya1xteWRvY3VtZW50LnR4dDwvZmlsZW5hbWU+LgoJPC9wYXJhPgoJPHBhcmE+CgkgIFNvIG11Y2ggZm9yIHRoZSBXaW5kb3dzIHdheSBvZiBkb2luZyB0aGluZ3MuCgk8L3BhcmE+Cgk8cGFyYT4KCSAgV2VsbCwgdGhlIHByb2JsZW0gaXMsIGluIFVuaXggdGhlcmUgaXMgbm8gc3VjaCB0aGluZyBhcwoJICA8cXVvdGU+ZHJpdmUgbGV0dGVyczwvcXVvdGU+LiBJbnN0ZWFkLCBVbml4IGNob3NlIHRvIGdvIHRoZQoJICBtdWNoIGJldHRlciB3YXkgb2YgaGF2aW5nIG9uZSBzaW5nbGUgdW5pZm9ybSBkaXJlY3RvcnkgdHJlZQoJICAoc3RhcnRpbmcgd2l0aCB0aGUgcm9vdCBkaXJlY3RvcnkKCSAgPGZpbGVuYW1lPi88L2ZpbGVuYW1lPiksIHdoaWNoIGhhcyB2YXJpb3VzIHN0b3JhZ2UgZGV2aWNlcwoJICBzdWNoIGFzIGUuZy4gaGFyZGRpc2sgcGFydGl0aW9ucyBhcHBlbmRlZCBhdCB2YXJpb3VzIGRpcmVjdG9yeQoJICBsb2NhdGlvbnMgd2l0aGluIHRoZSB0cmVlIChhbiBleGFtcGxlIHdvdWxkIGJlCgkgIDxmaWxlbmFtZT4vZGF0YTEvbXl3b3JrPC9maWxlbmFtZT4sIHdoaWNoIGlzIHRoZSBmaXJzdCBkYXRhCgkgIHBhcnRpdGlvbiBtb3VudGVkL2F0dGFjaGVkIHRvIGEgZGlyZWN0b3J5IGNhbGxlZCBkYXRhMSBpbiB0aGUKCSAgcm9vdCBkaXJlY3RvcnkgPGZpbGVuYW1lPi88L2ZpbGVuYW1lPjsgbXl3b3JrIGlzIGEgc3ViCgkgIGRpcmVjdG9yeSBvZiB0aGUgZGF0YSBwYXJ0aXRpb24gZmlsZSBzeXN0ZW0gdGhhdCdzIG1vdW50ZWQKCSAgdW5kZXIgPGZpbGVuYW1lPi9kYXRhMTwvZmlsZW5hbWU+KS4KCSAgSW4gVW5peCwgdGhlIFdpbmRvd3MgZXhhbXBsZSBkb2N1bWVudCBtZW50aW9uZWQgYWJvdmUgY291bGQgZS5nLgoJICBiZSBhY2Nlc3NlZCBieSB0aGUgbmFtZSBvZgoJICA8ZmlsZW5hbWU+L2RhdGExL215d29yay9teWRvY3VtZW50LnR4dDwvZmlsZW5hbWU+LAoJICBwcm92aWRlZCB0aGF0IHRoZSBhZG1pbmlzdHJhdG9yIGRlY2lkZWQgdG8gbW91bnQgKGF0dGFjaCkgdGhlIGZpcnN0CgkgIGRhdGEgcGFydGl0aW9uIGF0IHRoZSBkaXJlY3RvcnkgL2RhdGExIGluc2lkZSB0aGUgVW5peAoJICBkaXJlY3RvcnkgdHJlZS4gTm90ZSB0aGF0IGluIFVuaXgsIHRoZSBhZG1pbmlzdHJhdG9yIGNhbgoJICA8ZW1waGFzaXM+Y2hvb3NlPC9lbXBoYXNpcz4gYW55IGN1c3RvbSBwYXJ0aXRpb24gbG9jYXRpb24gaGUKCSAgd2FudHMgKGhlcmUsIDxmaWxlbmFtZT4vZGF0YTE8L2ZpbGVuYW1lPiksIHdoZXJlYXMgaW4gV2luZG93cyB0aGUgc3lzdGVtCgkgIDxlbXBoYXNpcz5zZWxlY3RzPC9lbXBoYXNpcz4gYW55IGRyaXZlIGxldHRlciBpdCBkZWVtcwoJICBzdWl0YWJsZSBmb3IgdGhlIGZpcnN0IGRhdGEgcGFydGl0aW9uIChoZXJlLAoJICA8ZmlsZW5hbWU+RDo8L2ZpbGVuYW1lPiksIGFuZCwgZXZlbiB3b3JzZSwgaWYgdGhlcmUgaXMgc29tZQoJICBjaGFuZ2UgaW4gcGFydGl0aW9uIG9yZGVyLCBXaW5kb3dzIGF1dG9tYXRpY2FsbHkKCSAgPGVtcGhhc2lzPmNoYW5nZXM8L2VtcGhhc2lzPiB0aGUgZHJpdmUgbGV0dGVyLCBhbmQgeW91IG1pZ2h0CgkgIHN1ZGRlbmx5IGZpbmQgeW91cnNlbGYgd2l0aCBhIGZpcnN0IGRhdGEgcGFydGl0aW9uIGF0IGRyaXZlCgkgIGxldHRlciA8ZmlsZW5hbWU+RTo8L2ZpbGVuYW1lPiwgd2l0aCBhbGwgdGhlIGZpbGUgbmFtaW5nIGFuZAoJICByZWZlcmVuY2luZyBjb25mdXNpb24gdGhhdCBlbnRhaWxzLiBUaHVzLCB0aGUgV2luZG93cyB3YXkgb2YKCSAgdXNpbmcgZXZlci1jaGFuZ2luZyBkcml2ZSBsZXR0ZXJzIGlzIDxlbXBoYXNpcz5jbGVhcmx5CgkgIGluZmVyaW9yPC9lbXBoYXNpcz4gdG8gdGhlIFVuaXggd2F5IG9mIGFzc2lnbmluZwoJICA8ZW1waGFzaXM+Zml4ZWQ8L2VtcGhhc2lzPiBkaXJlY3RvcnkgdHJlZSBsb2NhdGlvbnMgZm9yIGV2ZXJ5CgkgIGRhdGEgc3RvcmFnZSBtZWRpdW0uCgkgIEFzIHdlJ2xsIHNlZSBzb29uLCBmb3J0dW5hdGVseSB0aGlzIFdpbmRvd3MgbGltaXRhdGlvbiBvZgoJICBjaGFuZ2luZyBkcml2ZSBsZXR0ZXJzIGRvZXNuJ3QgYWZmZWN0IHVzIGluIFdpbmUgYXQgYWxsLCBzaW5jZQoJICB3ZSBjYW4gcHJvcGVybHkgbWFwIDxlbXBoYXNpcz5uZXZlci1jaGFuZ2luZzwvZW1waGFzaXM+IGRyaXZlIGxldHRlcnMgdG8gPGVtcGhhc2lzPmZpeGVkPC9lbXBoYXNpcz4gbG9jYXRpb25zIGluc2lkZSB0aGUgVW5peCBkaXJlY3RvcnkgdHJlZSAoYW5kIGV2ZW4gaWYgdGhlIGxvY2F0aW9uIG9mIHRoZSByZXNwZWN0aXZlIFVuaXggZGlyZWN0b3J5IGNoYW5nZXMsIHdlIGNhbiBzdGlsbCBzaW1wbHkgdXBkYXRlIHRoZSBXaW5lIGRyaXZlIG1hcHBpbmcgdG8gcmVmbGVjdCB0aGUgdXBkYXRlZCBsb2NhdGlvbiBhbmQgYXQgdGhlIHNhbWUgdGltZSBrZWVwIHRoZSBvcmlnaW5hbCBkcml2ZSBsZXR0ZXIpLgoJPC9wYXJhPgoJPHBhcmE+CgkgIE9LLCBub3cgdGhhdCB3ZSBrbm93IHNvbWUgdGhlb3J5IGFib3V0IFdpbmRvd3MgYW5kIFVuaXggZHJpdmUKCSAgYW5kIGZpbGVuYW1lIG1hcHBpbmcsIGl0J3MgcHJvYmFibHkgdGltZSB0byBhc2sgaG93IFdpbmUKCSAgYWNoaWV2ZXMgdGhlIG1hZ2ljIG9mIG1hcHBpbmcgYSBVbml4IGRpcmVjdG9yeSBsb2NhdGlvbiB0byBhCgkgIFdpbmRvd3MgZHJpdmUuLi4KCTwvcGFyYT4KCTxwYXJhPgogICAgICAgICAgV2luZSBjaG9zZSB0byBkbyB0aGUgZm9sbG93aW5nOgoJICBJbiBXaW5lLCB5b3UgZG9uJ3QgYXNzaWduIHNvbWUgcmVhbCBwaHlzaWNhbCBzdG9yYWdlIG1lZGl1bQoJICAoc3VjaCBhcyBhIGhhcmRkaXNrIHBhcnRpdGlvbiBvciBzaW1pbGFyKSB0byBlYWNoIGRyaXZlIGxldHRlcgoJICBtYXBwaW5nIGVudHJ5LgogICAgICAgICAgSW5zdGVhZCwgeW91IGNob29zZSBjZXJ0YWluIHN1YiBkaXJlY3RvcnkgdHJlZXMgaW5zaWRlIHRoZSBVbml4CiAgICAgICAgICBkaXJlY3RvcnkgdHJlZSAodGhhdCBzdGFydHMgd2l0aCA8ZmlsZW5hbWU+LzwvZmlsZW5hbWU+KSB0aGF0CiAgICAgICAgICB5b3Ugd291bGQgbGlrZSB0byBhc3NpZ24gYSBkcml2ZSBsZXR0ZXIgdG8uCgk8L3BhcmE+Cgk8cGFyYT4KCSAgTm90ZSB0aGF0IGZvciBldmVyeSBVbml4IHN1YiBkaXJlY3RvcnkgdHJlZSB0aGF0IHlvdSBpbnRlbmQgdG8KCSAgc3RhcnQgV2luZG93cyBwcm9ncmFtcyBpbiwgaXQgaXMgPGVtcGhhc2lzPmFic29sdXRlbHkKCSAgcmVxdWlyZWQ8L2VtcGhhc2lzPiB0byBoYXZlIGEgV2luZSBkcml2ZSBtYXBwaW5nIGVudHJ5OgoJPC9wYXJhPgoJPHBhcmE+CgkgIEZvciBleGFtcGxlLCBpZiB5b3UgaGFkIGEgcHVibGljbHkgd3JpdGFibGUgPHF1b3RlPldpbmRvd3MKCSAgZGlyZWN0b3J5IHNwYWNlPC9xdW90ZT4gdW5kZXIgPGZpbGVuYW1lPi91c3IvbXl3aW5lPC9maWxlbmFtZT4sIHRoZW4gaW4gb3JkZXIgdG8gYmUKCSAgYWJsZSB0byBhY2Nlc3MgdGhpcyBzdWIgZGlyZWN0b3J5IHRyZWUgZnJvbSBXaW5lLCB5b3Ugc2hvdWxkCgkgIGhhdmUgYSBkcml2ZSBtYXBwaW5nIGVudHJ5IHRoYXQgbWFwcyBhIGNlcnRhaW4gZHJpdmUgbGV0dGVyCgkgIChmb3IgZXhhbXBsZSwgbGV0J3MgdGFrZSBkcml2ZSBsZXR0ZXIgPGZpbGVuYW1lPlA6PC9maWxlbmFtZT4pCgkgIGVpdGhlciB0byA8ZmlsZW5hbWU+L3Vzci9teXdpbmU8L2ZpbGVuYW1lPiBvciA8ZmlsZW5hbWU+L3VzcjwvZmlsZW5hbWU+ICh0byBhbHNvIGFjY2VzcyBhbnkgZGlyZWN0b3JpZXMgYmVsb25naW5nIHRvIHRoZSBwYXJlbnQgZGlyZWN0b3J5KSBvciA8ZmlsZW5hbWU+LzwvZmlsZW5hbWU+ICh0byBhbHNvIGFjY2VzcyBhbnkgZGlyZWN0b3J5IHdoYXRzb2V2ZXIgb24gdGhpcyBzeXN0ZW0gYnkgdGhpcyBkcml2ZSBsZXR0ZXIgbWFwcGluZykuIFRoZSBET1MgZHJpdmUvZGlyZWN0b3J5IGxvY2F0aW9uIHRvIGFjY2VzcyBmaWxlcyBpbiA8ZmlsZW5hbWU+L3Vzci9teXdpbmU8L2ZpbGVuYW1lPiA8ZW1waGFzaXM+aW4gV2luZTwvZW1waGFzaXM+IGluIHRoZXNlIGNvbmZpZ3VyYXRpb24gY2FzZXMgd291bGQgdGhlbiBiZSA8ZmlsZW5hbWU+UDpcPC9maWxlbmFtZT4gb3IgPGZpbGVuYW1lPlA6XG15d2luZTwvZmlsZW5hbWU+IG9yIDxmaWxlbmFtZT5QOlx1c3JcbXl3aW5lPC9maWxlbmFtZT4sIHJlc3BlY3RpdmVseS4KCTwvcGFyYT4KICAgICAgPC9zZWN0Mj4KCiAgICAgIDxzZWN0MiBpZD0iY29uZmlnLW5vLXdpbmRvd3MiPgogICAgICAgIDx0aXRsZT5JbnN0YWxsaW5nIFdpbmUgV2l0aG91dCBXaW5kb3dzPC90aXRsZT4KICAgICAgICA8cGFyYT4KICAgICAgICAgIFdyaXR0ZW4gYnkgJm5hbWUtamFtZXMtanVyYW47IDxlbWFpbD4mZW1haWwtamFtZXMtanVyYW47PC9lbWFpbD4KICAgICAgICA8L3BhcmE+CiAgICAgICAgPHBhcmE+CiAgICAgICAgICAoRXh0cmFjdGVkIGZyb20gPGZpbGVuYW1lPndpbmUvZG9jdW1lbnRhdGlvbi9uby13aW5kb3dzPC9maWxlbmFtZT4pCiAgICAgICAgPC9wYXJhPgoKICAgICAgICA8cGFyYT4KICAgICAgICAgIEEgbWFqb3IgZ29hbCBvZiBXaW5lIGlzIHRvIGFsbG93IHVzZXJzIHRvIHJ1biBXaW5kb3dzIHByb2dyYW1zCiAgICAgICAgICB3aXRob3V0IGhhdmluZyB0byBpbnN0YWxsIFdpbmRvd3Mgb24gdGhlaXIgbWFjaGluZS4gV2luZQogICAgICAgICAgaW1wbGVtZW50cyB0aGUgZnVuY3Rpb25hbGl0eSBvZiB0aGUgbWFpbiBETExzIHVzdWFsbHkKICAgICAgICAgIHByb3ZpZGVkIHdpdGggV2luZG93cy4gVGhlcmVmb3JlLCBvbmNlIFdpbmUgaXMgZmluaXNoZWQsIHlvdQogICAgICAgICAgd2lsbCBub3QgbmVlZCB0byBoYXZlIFdpbmRvd3MgaW5zdGFsbGVkIHRvIHVzZSBXaW5lLgogICAgICAgIDwvcGFyYT4KICAgICAgICA8cGFyYT4KICAgICAgICAgIFdpbmUgaGFzIGFscmVhZHkgbWFkZSBlbm91Z2ggcHJvZ3Jlc3MgdGhhdCBpdCBtYXkgYmUgcG9zc2libGUKICAgICAgICAgIHRvIHJ1biB5b3VyIHRhcmdldCBwcm9ncmFtcyB3aXRob3V0IFdpbmRvd3MgaW5zdGFsbGVkLiBJZgogICAgICAgICAgeW91IHdhbnQgdG8gdHJ5IGl0LCBmb2xsb3cgdGhlc2Ugc3RlcHM6CiAgICAgICAgPC9wYXJhPgoKICAgICAgICA8b3JkZXJlZGxpc3Q+CiAgICAgICAgICA8bGlzdGl0ZW0+CiAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgIFBvaW50IDxtZWRpYWxhYmVsPltEcml2ZSBDXTwvbWVkaWFsYWJlbD4gaW4KICAgICAgICAgICAgICA8ZmlsZW5hbWU+fi8ud2luZS9jb25maWc8L2ZpbGVuYW1lPiB0byB0aGUgZGlyZWN0b3J5IHdoZXJlIHlvdSB3YW50CiAgICAgICAgICAgICAgPGZpbGVuYW1lPkM6PC9maWxlbmFtZT4gdG8gYmUuIFJlZmVyIHRvIHRoZSB3aW5lLmNvbmYgbWFuIHBhZ2UKICAgICAgICAgICAgICBmb3IgbW9yZSBpbmZvcm1hdGlvbi4KICAJICAgIFRoZSBkaXJlY3RvcnkgdG8gYmUgdXNlZCBmb3IgZW11bGF0aW5nIGEgQzogZHJpdmUgd2lsbCBiZQogIAkgICAgdGhlIGJhc2UgZGlyZWN0b3J5IGZvciBzb21lIFdpbmRvd3Mgc3BlY2lmaWMgZGlyZWN0b3JpZXMKICAJICAgIGNyZWF0ZWQgYmVsb3cuCiAgCSAgICBSZW1lbWJlciB0byB1c2UKICAgICAgICAgICAgICA8dXNlcmlucHV0PiJGaWxlc3lzdGVtIiA9ICJ3aW45NSI8L3VzZXJpbnB1dD4hCiAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgICAgICA8bGlzdGl0ZW0+CiAgICAgICAgICAgIDxwYXJhPgogIAkgICAgV2l0aGluIHRoZSBkaXJlY3RvcnkgdG8gYmUgdXNlZCBmb3IgQzosIGNyZWF0ZSBlbXB0eQogIAkgICAgPGZpbGVuYW1lPndpbmRvd3M8L2ZpbGVuYW1lPiwKICAgICAgICAgICAgICA8ZmlsZW5hbWU+d2luZG93cy9zeXN0ZW08L2ZpbGVuYW1lPiwKICAgICAgICAgICAgICA8ZmlsZW5hbWU+d2luZG93cy9TdGFydCBNZW51PC9maWxlbmFtZT4sIGFuZAogICAgICAgICAgICAgIDxmaWxlbmFtZT53aW5kb3dzL1N0YXJ0IE1lbnUvUHJvZ3JhbXM8L2ZpbGVuYW1lPgogICAgICAgICAgICAgIGRpcmVjdG9yaWVzLiBEbyBub3QgcG9pbnQgV2luZSB0byBhCiAgICAgICAgICAgICAgPGZpbGVuYW1lPldpbmRvd3M8L2ZpbGVuYW1lPiBkaXJlY3RvcnkgZnVsbCBvZiBvbGQKICAgICAgICAgICAgICBpbnN0YWxsYXRpb25zIGFuZCBhIG1lc3N5IHJlZ2lzdHJ5LiAoV2luZSBjcmVhdGVzIGEKICAgICAgICAgICAgICBzcGVjaWFsIHJlZ2lzdHJ5IGluIHlvdXIgPGZpbGVuYW1lID5ob21lPC9maWxlbmFtZT4KICAgICAgICAgICAgICBkaXJlY3RvcnksIGluIDxmaWxlbmFtZT4kSE9NRS8ud2luZS8qLnJlZzwvZmlsZW5hbWU+LgogICAgICAgICAgICAgIFBlcmhhcHMgeW91IGhhdmUgdG8gcmVtb3ZlIHRoZXNlIGZpbGVzKS4KICAJICAgIEluIG9uZSBsaW5lOgogIAkgICAgbWtkaXIgLXAgd2luZG93cyB3aW5kb3dzL3N5c3RlbSB3aW5kb3dzL1N0YXJ0XCBNZW51IHdpbmRvd3MvU3RhcnRcIE1lbnUvUHJvZ3JhbXMKICAgICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPC9saXN0aXRlbT4KICAgICAgICAgIDxsaXN0aXRlbT4KICAgICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgICAgUnVuIGFuZC9vciBpbnN0YWxsIHlvdXIgcHJvZ3JhbXMuCiAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgICAgPC9vcmRlcmVkbGlzdD4KCiAgICAgICAgPHBhcmE+CiAgICAgICAgICBCZWNhdXNlIFdpbmUgaXMgbm90IHlldCBjb21wbGV0ZSwgc29tZSBwcm9ncmFtcyB3aWxsIHdvcmsKICAgICAgICAgIGJldHRlciB3aXRoIG5hdGl2ZSBXaW5kb3dzIERMTHMgdGhhbiB3aXRoIFdpbmUncwogICAgICAgICAgcmVwbGFjZW1lbnRzLiBXaW5lIGhhcyBiZWVuIGRlc2lnbmVkIHRvIG1ha2UgdGhpcyBwb3NzaWJsZS4KICAgICAgICAgIEhlcmUgYXJlIHNvbWUgdGlwcyBieSBKdWVyZ2VuIFNjaG1pZWQgKGFuZCBvdGhlcnMpIG9uIGhvdyB0bwogICAgICAgICAgcHJvY2VlZC4gVGhpcyBhc3N1bWVzIHRoYXQgeW91cgogICAgICAgICAgPGZpbGVuYW1lPkM6XHdpbmRvd3M8L2ZpbGVuYW1lPiBkaXJlY3RvcnkgaW4gdGhlIGNvbmZpZ3VyYXRpb24KICAgICAgICAgIGZpbGUgZG9lcyBub3QgcG9pbnQgdG8gYSBuYXRpdmUgV2luZG93cyBpbnN0YWxsYXRpb24gYnV0IGlzIGluCiAgICAgICAgICBhIHNlcGFyYXRlIFVuaXggZmlsZSBzeXN0ZW0uIChGb3IgaW5zdGFuY2UsIDxxdW90ZT5DOlx3aW5kb3dzPC9xdW90ZT4gaXMKICAgICAgICAgIHJlYWxseSBzdWJkaXJlY3RvcnkgPHF1b3RlPndpbmRvd3M8L3F1b3RlPiBsb2NhdGVkIGluCiAgICAgICAgICA8cXVvdGU+L2hvbWUvZWdvL3dpbmUvZHJpdmVzL2M8L3F1b3RlPikuCiAgICAgICAgPC9wYXJhPgoKICAgICAgICA8aXRlbWl6ZWRsaXN0PgogICAgICAgICAgPGxpc3RpdGVtPgogICAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgICBSdW4gdGhlIHByb2dyYW0gd2l0aCA8cGFyYW1ldGVyPi0tZGVidWdtc2cKICAgICAgICAgICAgICAgICtsb2FkZGxsPC9wYXJhbWV0ZXI+IHRvIGZpbmQgb3V0IHdoaWNoIGZpbGVzIGFyZQogICAgICAgICAgICAgIG5lZWRlZC4gQ29weSB0aGUgcmVxdWlyZWQgRExMcyBvbmUgYnkgb25lIHRvIHRoZQogICAgICAgICAgICAgIDxmaWxlbmFtZT5DOlx3aW5kb3dzXHN5c3RlbTwvZmlsZW5hbWU+IGRpcmVjdG9yeS4gRG8gbm90CiAgICAgICAgICAgICAgY29weSBLRVJORUwvS0VSTkVMMzIsIEdESS9HREkzMiwgVVNFUi9VU0VSMzIgb3IgTlRETEwuIFRoZXNlCiAgICAgICAgICAgICAgaW1wbGVtZW50IHRoZSBjb3JlIGZ1bmN0aW9uYWxpdHkgb2YgdGhlIFdpbmRvd3MgQVBJLCBhbmQKICAgICAgICAgICAgICB0aGUgV2luZSBpbnRlcm5hbCB2ZXJzaW9ucyBtdXN0IGJlIHVzZWQuCiAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgICAgICA8bGlzdGl0ZW0+CiAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgIEVkaXQgdGhlIDxxdW90ZT5bRGxsT3ZlcnJpZGVzXTwvcXVvdGU+IHNlY3Rpb24gb2YKICAgICAgICAgICAgICA8ZmlsZW5hbWU+fi8ud2luZS9jb25maWc8L2ZpbGVuYW1lPiB0byBzcGVjaWZ5CiAgICAgICAgICAgICAgPHF1b3RlPm5hdGl2ZTwvcXVvdGU+IGJlZm9yZSA8cXVvdGU+YnVpbHRpbjwvcXVvdGU+IGZvcgogICAgICAgICAgICAgIHRoZSBXaW5kb3dzIERMTHMgeW91IHdhbnQgdG8gdXNlLiBGb3IgbW9yZSBpbmZvcm1hdGlvbgogICAgICAgICAgICAgIGFib3V0IHRoaXMsIHNlZSB0aGUgV2luZSBtYW5wYWdlLgogICAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8L2xpc3RpdGVtPgogICAgICAgICAgPGxpc3RpdGVtPgogICAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgICBOb3RlIHRoYXQgc29tZSBuZXR3b3JrIERMTHMgYXJlIG5vdCBuZWVkZWQgZXZlbiB0aG91Z2gKICAgICAgICAgICAgICBXaW5lIGlzIGxvb2tpbmcgZm9yIHRoZW0uIFRoZSBXaW5kb3dzCiAgICAgICAgICAgICAgPGZpbGVuYW1lPk1QUi5ETEw8L2ZpbGVuYW1lPiBjdXJyZW50bHkgZG9lcyBub3Qgd29yazsgeW91CiAgICAgICAgICAgICAgbXVzdCB1c2UgdGhlIGludGVybmFsIGltcGxlbWVudGF0aW9uLgogICAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8L2xpc3RpdGVtPgogICAgICAgICAgPGxpc3RpdGVtPgogICAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgICBDb3B5IFNIRUxMLkRMTC9TSEVMTDMyLkRMTCwgQ09NTURMRy5ETEwvQ09NRExHMzIuRExMCgkgICAgICBhbmQgQ09NTUNUUkwuRExML0NPTUNUTDMyLkRMTAogICAgICAgICAgICAgIG9ubHkgYXMgcGFpcnMgdG8geW91ciBXaW5lIGRpcmVjdG9yeSAodGhlc2UgRExMcyBhcmUKICAgICAgICAgICAgICA8cXVvdGU+Y2xlYW48L3F1b3RlPiB0byB1c2UpLiAgTWFrZSBzdXJlIHlvdSBoYXZlIHRoZXNlCiAgICAgICAgICAgICAgc3BlY2lmaWVkIGluIHRoZSA8cXVvdGU+W0RsbFBhaXJzXTwvcXVvdGU+IHNlY3Rpb24gb2YKICAgICAgICAgICAgICA8ZmlsZW5hbWU+fi8ud2luZS9jb25maWc8L2ZpbGVuYW1lPi4KICAgICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPC9saXN0aXRlbT4KICAgICAgICAgIDxsaXN0aXRlbT4KICAgICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgICAgQmUgY29uc2lzdGVudDogVXNlIG9ubHkgRExMcyBmcm9tIHRoZSBzYW1lIFdpbmRvd3MgdmVyc2lvbgogICAgICAgICAgICAgIHRvZ2V0aGVyLgogICAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8L2xpc3RpdGVtPgogICAgICAgICAgPGxpc3RpdGVtPgogICAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgICBQdXQgPGZpbGVuYW1lPnJlZ2VkaXQuZXhlPC9maWxlbmFtZT4gaW4gdGhlCiAgICAgICAgICAgICAgPGZpbGVuYW1lPkM6XHdpbmRvd3M8L2ZpbGVuYW1lPiBkaXJlY3RvcnkuCiAgICAgICAgICAgICAgKDxhcHBsaWNhdGlvbj5PZmZpY2UgOTU8L2FwcGxpY2F0aW9uPiBpbXBvcnRzIGEKICAgICAgICAgICAgICA8ZmlsZW5hbWU+Ki5yZWc8L2ZpbGVuYW1lPiBmaWxlIHdoZW4gaXQgcnVucyB3aXRoIGFuIGVtcHR5CiAgICAgICAgICAgICAgcmVnaXN0cnksIGRvbid0IGtub3cgYWJvdXQKICAgICAgICAgICAgICA8YXBwbGljYXRpb24+T2ZmaWNlIDk3PC9hcHBsaWNhdGlvbj4pLgoJICAgICAgQXMgb2Ygbm93LCBpdCBtaWdodCBub3QgYmUgbmVjZXNzYXJ5IGFueSBtb3JlIHRvIHVzZQoJICAgICAgcmVnZWRpdC5leGUsIHNpbmNlIFdpbmUgaGFzIGl0cyBvd24gcmVnZWRpdCBXaW5lbGliCgkgICAgICBhcHBsaWNhdGlvbiBub3cuCiAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgICAgICA8bGlzdGl0ZW0+CiAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgIEFsc28gYWRkIDxmaWxlbmFtZT53aW5oZWxwLmV4ZTwvZmlsZW5hbWU+IGFuZAogICAgICAgICAgICAgIDxmaWxlbmFtZT53aW5obHAzMi5leGU8L2ZpbGVuYW1lPiBpZiB5b3Ugd2FudCB0byBiZSBhYmxlCiAgICAgICAgICAgICAgdG8gYnJvd3NlIHRocm91Z2ggeW91ciBwcm9ncmFtcycgaGVscCBmdW5jdGlvbgogIAkgICAgKG9yIGluIGNhc2UgV2luZSdzIHdpbmhlbHAgaW1wbGVtZW50YXRpb24gaW4gcHJvZ3JhbXMvd2luaGVscC8KICAJICAgIGlzIG5vdCBnb29kIGVub3VnaCwgZm9yIGV4YW1wbGUpLgogICAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8L2xpc3RpdGVtPgogICAgICAgIDwvaXRlbWl6ZWRsaXN0PgogICAgICA8L3NlY3QyPgoKICAgICAgPHNlY3QyIGlkPSJjb25maWctd2l0aC13aW5kb3dzIj4KICAgICAgICA8dGl0bGU+SW5zdGFsbGluZyBXaW5lIFVzaW5nIEFuIEV4aXN0aW5nIFdpbmRvd3MgUGFydGl0aW9uIEFzIEJhc2U8L3RpdGxlPgogICAgICAgIDxwYXJhPgogICAgICAgICAgU29tZSBwZW9wbGUgaW50ZW5kIHRvIHVzZSB0aGUgZGF0YSBvZiBhbiBleGlzdGluZyBXaW5kb3dzIHBhcnRpdGlvbgogIAl3aXRoIFdpbmUgaW4gb3JkZXIgdG8gZ2FpbiBzb21lIGJldHRlciBjb21wYXRpYmlsaXR5IG9yIHRvIHJ1biBhbHJlYWR5CiAgCWluc3RhbGxlZCBwcm9ncmFtcyBpbiBhIHNldHVwIGFzIG9yaWdpbmFsIGFzIHBvc3NpYmxlLgogIAlOb3RlIHRoYXQgbWFueSBXaW5kb3dzIHByb2dyYW1zIGFzc3VtZSB0aGF0IHRoZXkgaGF2ZSBmdWxsIHdyaXRlCiAgCWFjY2VzcyB0byBhbGwgd2luZG93cyBkaXJlY3Rvcmllcy4KCiAgCVRoaXMgbWVhbnMgdGhhdCB5b3UgZWl0aGVyIGhhdmUgdG8gY29uZmlndXJlIHRoZSBXaW5kb3dzCiAgCXBhcnRpdGlvbiBtb3VudCBwb2ludCBmb3Igd3JpdGUgcGVybWlzc2lvbiBieSB5b3VyIFdpbmUgdXNlcgogIAkoc2VlIDxsaW5rIGxpbmtlbmQ9ImNvbmZpZy1kcml2ZS12ZmF0Ij5EZWFsaW5nIHdpdGggRkFUL1ZGQVQgcGFydGl0aW9uczwvbGluaz4KICAJb24gaG93IHRvIGRvIHRoYXQpLCBvciB5b3UnbGwgaGF2ZSB0byBjb3B5IG92ZXIgKHNvbWUgcGFydHMgb2YpIHRoZSBXaW5kb3dzCiAgCXBhcnRpdGlvbiBjb250ZW50IHRvIGEgZGlyZWN0b3J5IG9mIGEgVW5peCBwYXJ0aXRpb24gYW5kIG1ha2UKICAJc3VyZSB0aGlzIGRpcmVjdG9yeSBzdHJ1Y3R1cmUgaXMgd3JpdGFibGUgYnkgeW91ciB1c2VyLgogIAlXZSA8ZW1waGFzaXM+SElHSExZIERJU0NPVVJBR0U8L2VtcGhhc2lzPiBwZW9wbGUgZnJvbSBkaXJlY3RseSB1c2luZyBhIFdpbmRvd3MgcGFydGl0aW9uIHdpdGgKICAJd3JpdGUgYWNjZXNzIGFzIGEgYmFzZSBmb3IgV2luZSEhIChzb21lIHByb2dyYW1zLCBub3RhYmx5CiAgCUV4cGxvcmVyLCBjb3JydXB0IGxhcmdlIHBhcnRzIG9mIHRoZSBXaW5kb3dzIHBhcnRpdGlvbiBpbiBjYXNlCiAgCW9mIGFuIGluY29ycmVjdCBzZXR1cDsgeW91J3ZlIGJlZW4gd2FybmVkKS4KICAJTm90IHRvIG1lbnRpb24gdGhhdCBOVEZTIHdyaXRlIHN1cHBvcnQgaW4gTGludXggaXMgc3RpbGwgdmVyeQogIAlleHBlcmltZW50YWwgYW5kIDxlbXBoYXNpcz5kYW5nZXJvdXM8L2VtcGhhc2lzPiAoaW4gY2FzZSB5b3UncmUgdXNpbmcgYW4gTlQtYmFzZWQKICAJV2luZG93cyB2ZXJzaW9uIHVzaW5nIHRoZSBOVEZTIGZpbGUgc3lzdGVtKS4KICAJVGh1cyB3ZSBhZHZpc2UgeW91IHRvIGdvIHRoZSBVbml4IGRpcmVjdG9yeSB3YXkuCiAgICAgICAgPC9wYXJhPgogICAgICA8L3NlY3QyPgoKICAgICAgPHNlY3QyIGlkPSJjb25maWctZHJpdmUtdmZhdCI+CiAgICAgICAgPHRpdGxlPkRlYWxpbmcgV2l0aCBGQVQvVkZBVCBQYXJ0aXRpb25zPC90aXRsZT4KICAgICAgICA8cGFyYT4KICAgICAgICAgIFdyaXR0ZW4gYnkgJm5hbWUtc3RldmVuLWVsbGlvdHQ7IDxlbWFpbD4mZW1haWwtc3RldmVuLWVsbGlvdHQ7PC9lbWFpbD4KICAgICAgICA8L3BhcmE+CiAgICAgICAgPHBhcmE+CiAgICAgICAgICAoRXh0cmFjdGVkIGZyb20gPGZpbGVuYW1lPndpbmUvZG9jdW1lbnRhdGlvbi9saW51eC1mYXQtcGVybWlzc2lvbnM8L2ZpbGVuYW1lPikKICAgICAgICA8L3BhcmE+CiAgICAgICAgPHBhcmE+CiAgICAgICAgICBUaGlzIGRvY3VtZW50IGRlc2NyaWJlcyBob3cgRkFUIGFuZAogICAgICAgICAgVkZBVCBmaWxlIHN5c3RlbSBwZXJtaXNzaW9ucyB3b3JrIGluIExpbnV4CiAgICAgICAgICB3aXRoIGEgZm9jdXMgb24gY29uZmlndXJpbmcgdGhlbSBmb3IgV2luZS4KICAgICAgICA8L3BhcmE+CgogICAgICAgIDxzZWN0Mz4KICAgICAgICAgIDx0aXRsZT5JbnRyb2R1Y3Rpb248L3RpdGxlPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIExpbnV4IGlzIGFibGUgdG8gYWNjZXNzIERPUyBhbmQgV2luZG93cyBmaWxlIHN5c3RlbXMgdXNpbmcKICAgICAgICAgICAgZWl0aGVyIHRoZSBGQVQgKG9sZGVyIDguMyBET1MgZmlsZXN5c3RlbXMpIG9yIFZGQVQgKG5ld2VyCiAgICAgICAgICAgIFdpbmRvd3MgOTUgb3IgbGF0ZXIgbG9uZyBmaWxlbmFtZSBmaWxlc3lzdGVtcykgbW9kdWxlcy4KICAgICAgICAgICAgTW91bnRlZCBGQVQgb3IgVkZBVCBmaWxlc3lzdGVtcyBwcm92aWRlIHRoZSBwcmltYXJ5IG1lYW5zCiAgICAgICAgICAgIGZvciB3aGljaCBleGlzdGluZyBwcm9ncmFtcyBhbmQgdGhlaXIgZGF0YSBhcmUgYWNjZXNzZWQKICAgICAgICAgICAgdGhyb3VnaCBXaW5lIGZvciBkdWFsIGJvb3QgKExpbnV4ICsgV2luZG93cykgc3lzdGVtcy4KICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICBXaW5lIG1hcHMgbW91bnRlZCBGQVQgZmlsZXN5c3RlbXMsIHN1Y2ggYXMKICAgICAgICAgICAgPGZpbGVuYW1lPi9jPC9maWxlbmFtZT4sIHRvIGRyaXZlciBsZXR0ZXJzLCBzdWNoIGFzCiAgICAgICAgICAgIDxxdW90ZT5jOjwvcXVvdGU+LCBhcyBpbmRpY2F0ZWQgYnkgdGhlCiAgICAgICAgICAgIDxmaWxlbmFtZT5+Ly53aW5lL2NvbmZpZzwvZmlsZW5hbWU+IGZpbGUuICBUaGUgZm9sbG93aW5nIGV4Y2VycHQKICAgICAgICAgICAgZnJvbSBhIDxmaWxlbmFtZT5+Ly53aW5lL2NvbmZpZzwvZmlsZW5hbWU+IGZpbGUgZG9lcyB0aGlzOgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHByb2dyYW1saXN0aW5nPgogIFtEcml2ZSBDXQogICJQYXRoIiA9ICIvYyIKICAiVHlwZSIgPSAiaGQiCiAgICAgICAgICA8L3Byb2dyYW1saXN0aW5nPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIEFsdGhvdWdoIFZGQVQgZmlsZXN5c3RlbXMgYXJlIHByZWZlcmFibGUgdG8gRkFUIGZpbGVzeXN0ZW1zCiAgICAgICAgICAgIGZvciB0aGVpciBsb25nIGZpbGVuYW1lIHN1cHBvcnQsIHRoZSB0ZXJtIDxxdW90ZT5GQVQ8L3F1b3RlPgogICAgICAgICAgICB3aWxsIGJlIHVzZWQgdGhyb3VnaG91dCB0aGUgcmVtYWluZGVyIG9mIHRoaXMgZG9jdW1lbnQgdG8KICAgICAgICAgICAgcmVmZXIgdG8gRkFUIGZpbGVzeXN0ZW1zIGFuZCB0aGVpciBkZXJpdmF0aXZlcy4gQWxzbywKICAgICAgICAgICAgPHF1b3RlPi9jPC9xdW90ZT4gd2lsbCBiZSB1c2VkIGFzIHRoZSBGQVQgbW91bnQgcG9pbnQgaW4KICAgICAgICAgICAgZXhhbXBsZXMgdGhyb3VnaG91dCB0aGlzIGRvY3VtZW50LgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIE1vc3QgbW9kZXJuIExpbnV4IGRpc3RyaWJ1dGlvbnMgZWl0aGVyIGRldGVjdCBvciBhbGxvdwogICAgICAgICAgICBleGlzdGluZyBGQVQgZmlsZSBzeXN0ZW1zIHRvIGJlIGNvbmZpZ3VyZWQgc28gdGhhdCB0aGV5IGNhbiBiZQogICAgICAgICAgICBtb3VudGVkLCBpbiBhIGxvY2F0aW9uIHN1Y2ggYXMgPGZpbGVuYW1lPi9jPC9maWxlbmFtZT4sCiAgICAgICAgICAgIGVpdGhlciBwZXJzaXN0ZW50bHkgKG9uIGJvb3R1cCkgb3Igb24gYW4gYXMgbmVlZGVkIGJhc2lzLiBJbgogICAgICAgICAgICBlaXRoZXIgY2FzZSwgYnkgZGVmYXVsdCwgdGhlIHBlcm1pc3Npb25zIHdpbGwgcHJvYmFibHkgYmUKICAgICAgICAgICAgY29uZmlndXJlZCBzbyB0aGF0IHRoZXkgbG9vayBsaWtlOgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHNjcmVlbj4KICA8cHJvbXB0Pn4+PC9wcm9tcHQ+PHVzZXJpbnB1dD5jZCAvYzwvdXNlcmlucHV0PgogIDxwcm9tcHQ+L2M+PC9wcm9tcHQ+PHVzZXJpbnB1dD5scyAtbDwvdXNlcmlucHV0PgogIDxjb21wdXRlcm91dHB1dD4tcnd4ci14ci14ICAgMSByb290ICAgICByb290ICAgICAgICAgICA5MSBPY3QgMTAgMTc6NTggYXV0b2V4ZWMuYmF0CiAgLXJ3eHIteHIteCAgIDEgcm9vdCAgICAgcm9vdCAgICAgICAgICAyNDUgT2N0IDEwIDE3OjU4IGNvbmZpZy5zeXMKICBkcnd4ci14ci14ICA0MSByb290ICAgICByb290ICAgICAgICAxNjM4NCBEZWMgMzAgIDE5OTggd2luZG93czwvY29tcHV0ZXJvdXRwdXQ+CiAgICAgICAgICA8L3NjcmVlbj4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICB3aGVyZSBhbGwgdGhlIGZpbGVzIGFyZSBvd25lZCBieSAicm9vdCIsIGFyZSBpbiB0aGUgInJvb3QiCiAgICAgICAgICAgIGdyb3VwIGFuZCBhcmUgb25seSB3cml0YWJsZSBieSAicm9vdCIKICAgICAgICAgICAgKDxsaXRlcmFsPjc1NTwvbGl0ZXJhbD4gcGVybWlzc2lvbnMpLiBUaGlzIGlzIHJlc3RyaWN0aXZlIGluCiAgICAgICAgICAgIHRoYXQgaXQgcmVxdWlyZXMgdGhhdCBXaW5lIGJlIHJ1biBhcyByb290IGluIG9yZGVyIGZvcgogICAgICAgICAgICBwcm9ncmFtcyB0byBiZSBhYmxlIHRvIHdyaXRlIHRvIGFueSBwYXJ0IG9mIHRoZQogICAgICAgICAgICBmaWxlc3lzdGVtLgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIFRoZXJlIGFyZSB0aHJlZSBtYWpvciBhcHByb2FjaGVzIHRvIG92ZXJjb21pbmcgdGhlIHJlc3RyaWN0aXZlCiAgICAgICAgICAgIHBlcm1pc3Npb25zIG1lbnRpb25lZCBpbiB0aGUgcHJldmlvdXMgcGFyYWdyYXBoOgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPG9yZGVyZWRsaXN0PgogICAgICAgICAgICA8bGlzdGl0ZW0+CiAgICAgICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgICAgICBSdW4gPGFwcGxpY2F0aW9uPldpbmU8L2FwcGxpY2F0aW9uPiBhcyByb290CiAgICAgICAgICAgICAgPC9wYXJhPgogICAgICAgICAgICA8L2xpc3RpdGVtPgogICAgICAgICAgICA8bGlzdGl0ZW0+CiAgICAgICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgICAgICBNb3VudCB0aGUgRkFUIGZpbGVzeXN0ZW0gd2l0aCBsZXNzIHJlc3RyaWN0aXZlCiAgICAgICAgICAgICAgICBwZXJtaXNzaW9ucwogICAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgICAgPC9saXN0aXRlbT4KICAgICAgICAgICAgPGxpc3RpdGVtPgogICAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgICAgU2hhZG93IHRoZSBGQVQgZmlsZXN5c3RlbSBieSBjb21wbGV0ZWx5IG9yIHBhcnRpYWxseQogICAgICAgICAgICAgICAgY29weWluZyBpdAogICAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgICAgPC9saXN0aXRlbT4KICAgICAgICAgIDwvb3JkZXJlZGxpc3Q+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgRWFjaCBhcHByb2FjaCB3aWxsIGJlIGRpc2N1c3NlZCBpbiB0aGUgZm9sbG93aW5nIHNlY3Rpb25zLgogICAgICAgICAgPC9wYXJhPgogICAgICAgIDwvc2VjdDM+CgogICAgICAgIDxzZWN0Mz4KICAgICAgICAgIDx0aXRsZT5SdW5uaW5nIFdpbmUgYXMgcm9vdDwvdGl0bGU+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgUnVubmluZyBXaW5lIGFzIHJvb3QgaXMgdGhlIGVhc2llc3QgYW5kIG1vc3QgdGhvcm91Z2ggd2F5IG9mIGdpdmluZwogICAgICAgICAgICBwcm9ncmFtcyB0aGF0IFdpbmUgcnVucyB1bnJlc3RyaWN0ZWQgYWNjZXNzIHRvIEZBVCBmaWxlcyBzeXN0ZW1zLgogICAgICAgICAgICBSdW5uaW5nIHdpbmUgYXMgcm9vdCBhbHNvIGFsbG93cyBwcm9ncmFtcyB0byBkbyB0aGluZ3MgdW5yZWxhdGVkCiAgICAgICAgICAgIHRvIEZBVCBmaWxlc3lzdGVtcywgc3VjaCBhcyBsaXN0ZW5pbmcgdG8gcG9ydHMgdGhhdCBhcmUgbGVzcyB0aGFuCiAgICAgICAgICAgIDEwMjQuICBSdW5uaW5nIFdpbmUgYXMgcm9vdCBpcyBkYW5nZXJvdXMgc2luY2UgdGhlcmUgaXMgbm8gbGltaXQgdG8KICAgICAgICAgICAgd2hhdCB0aGUgcHJvZ3JhbSBjYW4gZG8gdG8gdGhlIHN5c3RlbSwgc28gaXQncyA8ZW1waGFzaXM+SElHSExZIERJU0NPVVJBR0VEPC9lbXBoYXNpcz4uCiAgICAgICAgICA8L3BhcmE+CiAgICAgICAgPC9zZWN0Mz4KCiAgICAgICAgPHNlY3QzPgogICAgICAgICAgPHRpdGxlPk1vdW50aW5nIEZBVCBmaWxlc3lzdGVtczwvdGl0bGU+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgVGhlIEZBVCBmaWxlc3lzdGVtIGNhbiBiZSBtb3VudGVkIHdpdGggcGVybWlzc2lvbnMgbGVzcyByZXN0cmljdGl2ZQogICAgICAgICAgICB0aGFuIHRoZSBkZWZhdWx0LiAgVGhpcyBjYW4gYmUgZG9uZSBieSBlaXRoZXIgY2hhbmdpbmcgdGhlIHVzZXIgdGhhdAogICAgICAgICAgICBtb3VudHMgdGhlIEZBVCBmaWxlc3lzdGVtIG9yIGJ5IGV4cGxpY2l0bHkgY2hhbmdpbmcgdGhlIHBlcm1pc3Npb25zCiAgICAgICAgICAgIHRoYXQgdGhlIEZBVCBmaWxlc3lzdGVtIGlzIG1vdW50ZWQgd2l0aC4gIFRoZSBwZXJtaXNzaW9ucyBhcmUKICAgICAgICAgICAgaW5oZXJpdGVkIGZyb20gdGhlIHByb2Nlc3MgdGhhdCBtb3VudHMgdGhlIEZBVCBmaWxlc3lzdGVtLiAgU2luY2UgdGhlCiAgICAgICAgICAgIHByb2Nlc3MgdGhhdCBtb3VudHMgdGhlIEZBVCBmaWxlc3lzdGVtIGlzIHVzdWFsbHkgYSBzdGFydHVwIHNjcmlwdAogICAgICAgICAgICBydW5uaW5nIGFzIHJvb3QgdGhlIEZBVCBmaWxlc3lzdGVtIGluaGVyaXRzIHJvb3QncyBwZXJtaXNzaW9ucy4gIFRoaXMKICAgICAgICAgICAgcmVzdWx0cyBpbiB0aGUgZmlsZXMgb24gdGhlIEZBVCBmaWxlc3lzdGVtIGhhdmluZyBwZXJtaXNzaW9ucyBzaW1pbGFyCiAgICAgICAgICAgIHRvIGZpbGVzIGNyZWF0ZWQgYnkgcm9vdC4gIEZvciBleGFtcGxlOgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHNjcmVlbj4KICA8cHJvbXB0Pn4+PC9wcm9tcHQ+PHVzZXJpbnB1dD53aG9hbWk8L3VzZXJpbnB1dD4KICA8Y29tcHV0ZXJvdXRwdXQ+cm9vdDwvY29tcHV0ZXJvdXRwdXQ+CiAgPHByb21wdD5+PjwvcHJvbXB0Pjx1c2VyaW5wdXQ+dG91Y2ggcm9vdF9maWxlPC91c2VyaW5wdXQ+CiAgPHByb21wdD5+PjwvcHJvbXB0Pjx1c2VyaW5wdXQ+bHMgLWwgcm9vdF9maWxlPC91c2VyaW5wdXQ+CiAgPGNvbXB1dGVyb3V0cHV0PjwvY29tcHV0ZXJvdXRwdXQ+LXJ3LXItLXItLSAgIDEgcm9vdCAgICAgcm9vdCAgICAgICAgICAgIDAgRGVjIDEwIDAwOjIwIHJvb3RfZmlsZQogICAgICAgICAgPC9zY3JlZW4+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgd2hpY2ggbWF0Y2hlcyB0aGUgb3duZXIsIGdyb3VwIGFuZCBwZXJtaXNzaW9ucyBvZiBmaWxlcyBzZWVuCiAgICAgICAgICAgIG9uIHRoZSBGQVQgZmlsZXN5c3RlbSBleGNlcHQgZm9yIHRoZSBtaXNzaW5nICd4J3MuICBUaGUKICAgICAgICAgICAgcGVybWlzc2lvbnMgb24gdGhlIEZBVCBmaWxlc3lzdGVtIGNhbiBiZSBjaGFuZ2VkIGJ5IGNoYW5naW5nCiAgICAgICAgICAgIHJvb3QncyB1bWFzayAodW5zZXQgcGVybWlzc2lvbnMgYml0cykuICBGb3IgZXhhbXBsZToKICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDxzY3JlZW4+CiAgPHByb21wdD5+PjwvcHJvbXB0Pjx1c2VyaW5wdXQ+dW1vdW50IC9jPC91c2VyaW5wdXQ+CiAgPHByb21wdD5+PjwvcHJvbXB0Pjx1c2VyaW5wdXQ+dW1hc2s8L3VzZXJpbnB1dD4KICA8Y29tcHV0ZXJvdXRwdXQ+MDIyPC9jb21wdXRlcm91dHB1dD4KICA8cHJvbXB0Pn4+PC9wcm9tcHQ+PHVzZXJpbnB1dD51bWFzayAwNzM8L3VzZXJpbnB1dD4KICA8cHJvbXB0Pn4+PC9wcm9tcHQ+PHVzZXJpbnB1dD5tb3VudCAvYzwvdXNlcmlucHV0PgogIDxwcm9tcHQ+fj48L3Byb21wdD48dXNlcmlucHV0PmNkIC9jPC91c2VyaW5wdXQ+CiAgPHByb21wdD4vYz48L3Byb21wdD48dXNlcmlucHV0PmxzIC1sPC91c2VyaW5wdXQ+CiAgPGNvbXB1dGVyb3V0cHV0Pi1yd3gtLS1yLS0gICAxIHJvb3QgICAgIHJvb3QgICAgICAgICAgIDkxIE9jdCAxMCAxNzo1OCBhdXRvZXhlYy5iYXQKICAtcnd4LS0tci0tICAgMSByb290ICAgICByb290ICAgICAgICAgIDI0NSBPY3QgMTAgMTc6NTggY29uZmlnLnN5cwogIGRyd3gtLS1yLS0gIDQxIHJvb3QgICAgIHJvb3QgICAgICAgIDE2Mzg0IERlYyAzMCAgMTk5OCB3aW5kb3dzPC9jb21wdXRlcm91dHB1dD4KICAgICAgICAgIDwvc2NyZWVuPgogICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgIE1vdW50aW5nIHRoZSBGQVQgZmlsZXN5c3RlbSB3aXRoIGEgdW1hc2sgb2YKICAgICAgICAgICAgPGxpdGVyYWw+MDAwPC9saXRlcmFsPiBnaXZlcyBhbGwgdXNlcnMgY29tcGxldGUgY29udHJvbCBvdmVyCiAgICAgICAgICAgIGl0LiBFeHBsaWNpdGx5IHNwZWNpZnlpbmcgdGhlIHBlcm1pc3Npb25zIG9mIHRoZSBGQVQKICAgICAgICAgICAgZmlsZXN5c3RlbSB3aGVuIGl0IGlzIG1vdW50ZWQgcHJvdmlkZXMgYWRkaXRpb25hbCBjb250cm9sLgogICAgICAgICAgICBUaGVyZSBhcmUgdGhyZWUgbW91bnQgb3B0aW9ucyB0aGF0IGFyZSByZWxldmFudCB0byBGQVQKICAgICAgICAgICAgcGVybWlzc2lvbnM6IDxsaXRlcmFsPnVpZDwvbGl0ZXJhbD4sIDxsaXRlcmFsPmdpZDwvbGl0ZXJhbD4KICAgICAgICAgICAgYW5kIDxsaXRlcmFsPnVtYXNrPC9saXRlcmFsPi4gIFRoZXkgY2FuIGVhY2ggYmUgc3BlY2lmaWVkCiAgICAgICAgICAgIHdoZW4gdGhlIGZpbGVzeXN0ZW0gaXMgbWFudWFsbHkgbW91bnRlZC4gIEZvciBleGFtcGxlOgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHNjcmVlbj4KICA8cHJvbXB0Pn4+PC9wcm9tcHQ+PHVzZXJpbnB1dD51bW91bnQgL2M8L3VzZXJpbnB1dD4KICA8cHJvbXB0Pn4+PC9wcm9tcHQ+PHVzZXJpbnB1dD5tb3VudCAtbyB1aWQ9NTAwIC1vIGdpZD01MDAgLW8gdW1hc2s9MDAyIC9jPC91c2VyaW5wdXQ+CiAgPHByb21wdD5+PjwvcHJvbXB0Pjx1c2VyaW5wdXQ+Y2QgL2M8L3VzZXJpbnB1dD4KICA8cHJvbXB0Pi9jPjwvcHJvbXB0Pjx1c2VyaW5wdXQ+bHMgLWw8L3VzZXJpbnB1dD4KICA8Y29tcHV0ZXJvdXRwdXQ+LXJ3eHJ3eHIteCAgIDEgc2xlICAgICAgc2xlICAgICAgICAgICAgOTEgT2N0IDEwIDE3OjU4IGF1dG9leGVjLmJhdAogIC1yd3hyd3hyLXggICAxIHNsZSAgICAgIHNsZSAgICAgICAgICAgMjQ1IE9jdCAxMCAxNzo1OCBjb25maWcuc3lzCiAgZHJ3eHJ3eHIteCAgNDEgc2xlICAgICAgc2xlICAgICAgICAgMTYzODQgRGVjIDMwICAxOTk4IHdpbmRvd3M8L2NvbXB1dGVyb3V0cHV0PgogICAgICAgICAgPC9zY3JlZW4+CiAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgd2hpY2ggZ2l2ZXMgInNsZSIgY29tcGxldGUgY29udHJvbCBvdmVyCiAgICAgICAgICAgIDxmaWxlbmFtZT4vYzwvZmlsZW5hbWU+LiAgVGhlIG9wdGlvbnMgbGlzdGVkIGFib3ZlIGNhbiBiZQogICAgICAgICAgICBtYWRlIHBlcm1hbmVudCBieSBhZGRpbmcgdGhlbSB0byB0aGUKICAgICAgICAgICAgPGZpbGVuYW1lPi9ldGMvZnN0YWI8L2ZpbGVuYW1lPiBmaWxlOgogICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPHNjcmVlbj4KICA8cHJvbXB0Pn4+PC9wcm9tcHQ+PHVzZXJpbnB1dD5ncmVwIC9jIC9ldGMvZnN0YWI8L3VzZXJpbnB1dD4KICA8Y29tcHV0ZXJvdXRwdXQ+L2Rldi9oZGExICAvYyAgdmZhdCAgdWlkPTUwMCxnaWQ9NTAwLHVtYXNrPTAwMixleGVjLGRldixzdWlkLHJ3IDEgMTwvY29tcHV0ZXJvdXRwdXQ+CiAgICAgICAgICA8L3NjcmVlbj4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICBOb3RlIHRoYXQgdGhlIHVtYXNrIG9mIDxsaXRlcmFsPjAwMjwvbGl0ZXJhbD4gaXMgY29tbW9uIGluCiAgICAgICAgICAgIHRoZSB1c2VyIHByaXZhdGUgZ3JvdXAgZmlsZSBwZXJtaXNzaW9uIHNjaGVtZS4gIE9uIEZBVCBmaWxlCiAgICAgICAgICAgIHN5c3RlbXMgdGhpcyB1bWFzayBhc3N1cmVzIHRoYXQgYWxsIGZpbGVzIGFyZSBmdWxseQogICAgICAgICAgICBhY2Nlc3NpYmxlIGJ5IGFsbCB1c2VycyBpbiB0aGUgc3BlY2lmaWVkIHVzZXIgZ3JvdXAKICAgICAgICAgICAgKDxsaXRlcmFsPmdpZDwvbGl0ZXJhbD4pLgogICAgICAgICAgPC9wYXJhPgogICAgICAgIDwvc2VjdDM+CgogICAgICAgIDxzZWN0Mz4KICAgICAgICAgIDx0aXRsZT5TaGFkb3dpbmcgRkFUIGZpbGVzeXN0ZW1zPC90aXRsZT4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICBTaGFkb3dpbmcgcHJvdmlkZXMgYSBmaW5lciBncmFudWxhcml0eSBvZiBjb250cm9sLiAgUGFydHMgb2YKICAgICAgICAgICAgdGhlIG9yaWdpbmFsIEZBVCBmaWxlc3lzdGVtIGNhbiBiZSBjb3BpZWQgc28gdGhhdCB0aGUKICAgICAgICAgICAgcHJvZ3JhbSBjYW4gc2FmZWx5IHdvcmsgd2l0aCB0aG9zZSBjb3BpZWQgcGFydHMgd2hpbGUKICAgICAgICAgICAgdGhlIHByb2dyYW0gY29udGludWVzIHRvIGRpcmVjdGx5IHJlYWQgdGhlIHJlbWFpbmluZwogICAgICAgICAgICBwYXJ0cy4gIFRoaXMgaXMgZG9uZSB3aXRoIHN5bWJvbGljIGxpbmtzLiBGb3IgZXhhbXBsZSwKICAgICAgICAgICAgY29uc2lkZXIgYSBzeXN0ZW0gd2hlcmUgYSBwcm9ncmFtIG5hbWVkCiAgICAgICAgICAgIDxhcHBsaWNhdGlvbj5BbkFwcDwvYXBwbGljYXRpb24+IG11c3QgYmUgYWJsZSB0byByZWFkIGFuZAogICAgICAgICAgICB3cml0ZSB0byB0aGUgPGZpbGVuYW1lPmM6XHdpbmRvd3M8L2ZpbGVuYW1lPiBhbmQKICAgICAgICAgICAgPGZpbGVuYW1lPmM6XEFuQXBwPC9maWxlbmFtZT4gZGlyZWN0b3JpZXMgYXMgd2VsbCBhcyBoYXZlCiAgICAgICAgICAgIHJlYWQgYWNjZXNzIHRvIHRoZSBlbnRpcmUgRkFUIGZpbGVzeXN0ZW0uICBPbiB0aGlzIHN5c3RlbQogICAgICAgICAgICB0aGUgRkFUIGZpbGVzeXN0ZW0gaGFzIGRlZmF1bHQgcGVybWlzc2lvbnMgd2hpY2ggc2hvdWxkIG5vdAogICAgICAgICAgICBiZSBjaGFuZ2VkIGZvciBzZWN1cml0eSByZWFzb25zIG9yIGNhbiBub3QgYmUgY2hhbmdlZCBkdWUgdG8KICAgICAgICAgICAgbGFjayBvZiByb290IGFjY2Vzcy4gIE9uIHRoaXMgc3lzdGVtIGEgc2hhZG93IGRpcmVjdG9yeQogICAgICAgICAgICBtaWdodCBiZSBzZXQgdXAgaW4gdGhlIGZvbGxvd2luZyBtYW5uZXI6CiAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8c2NyZWVuPgogIDxwcm9tcHQ+fj48L3Byb21wdD48dXNlcmlucHV0PmNkIC88L3VzZXJpbnB1dD4KICA8cHJvbXB0Pi8+PC9wcm9tcHQ+PHVzZXJpbnB1dD5ta2RpciBjX3NoYWRvdzwvdXNlcmlucHV0PgogIDxwcm9tcHQ+Lz48L3Byb21wdD48dXNlcmlucHV0PmNkIGNfc2hhZG93PC91c2VyaW5wdXQ+CiAgPHByb21wdD4vY19zaGFkb3c+PC9wcm9tcHQ+PHVzZXJpbnB1dD5sbiAtcyAvY18vKiAuPC91c2VyaW5wdXQ+CiAgPHByb21wdD4vY19zaGFkb3c+PC9wcm9tcHQ+PHVzZXJpbnB1dD5ybSB3aW5kb3dzIEFuQXBwPC91c2VyaW5wdXQ+CiAgPHByb21wdD4vY19zaGFkb3c+PC9wcm9tcHQ+PHVzZXJpbnB1dD5jcCAtUiAvY18ve3dpbmRvd3MsQW5BcHB9IC48L3VzZXJpbnB1dD4KICA8cHJvbXB0Pi9jX3NoYWRvdz48L3Byb21wdD48dXNlcmlucHV0PmNobW9kIC1SIDc3NyB3aW5kb3dzIEFuQXBwPC91c2VyaW5wdXQ+Cjxwcm9tcHQ+L2Nfc2hhZG93PjwvcHJvbXB0Pjx1c2VyaW5wdXQ+cGVybCAtcCAtaSAtZSAnc3wvYyR8L2Nfc2hhZG93fGcnIH4vLndpbmUvY29uZmlnPC91c2VyaW5wdXQ+CiAgICAgICAgICA8L3NjcmVlbj4KICAgICAgICAgIDxwYXJhPgogICAgICAgICAgVGhlIGFib3ZlIGdpdmVzIGV2ZXJ5b25lIGNvbXBsZXRlIHJlYWQgYW5kIHdyaXRlIGFjY2VzcyB0bwogICAgICAgICAgdGhlIDxmaWxlbmFtZT53aW5kb3dzPC9maWxlbmFtZT4gYW5kCiAgICAgICAgICA8ZmlsZW5hbWU+QW5BcHA8L2ZpbGVuYW1lPiBkaXJlY3RvcmllcyB3aGlsZSBvbmx5IHJvb3QgaGFzCiAgICAgICAgICB3cml0ZSBhY2Nlc3MgdG8gYWxsIG90aGVyIGRpcmVjdG9yaWVzLgogICAgICAgICAgPC9wYXJhPgogICAgICAgIDwvc2VjdDM+CiAgICAgIDwvc2VjdDI+CgogICAgICA8c2VjdDIgaWQ9ImNvbmZpZy1kcml2ZS1jZHJvbS1sYWJlbHMiPgogICAgICA8c2VjdDJpbmZvPgogICAgICAgIDxhdXRob3Jncm91cD4KICAgICAgICAgIDxhdXRob3I+CiAgICAgICAgICAgIDxmaXJzdG5hbWU+UGV0cjwvZmlyc3RuYW1lPgogICAgICAgICAgICA8c3VybmFtZT5Ub21hc2VrPC9zdXJuYW1lPgogICAgICAgICAgICA8YWZmaWxpYXRpb24+CiAgICAgIAk8YWRkcmVzcz48ZW1haWw+JmVtYWlsLXBldHItdG9tYXNlazs8L2VtYWlsPjwvYWRkcmVzcz4KICAgICAgICAgICAgPC9hZmZpbGlhdGlvbj4KICAgICAgICAgICAgPGNvbnRyaWI+Tm92IDE0IDE5OTk8L2NvbnRyaWI+CiAgICAgICAgICA8L2F1dGhvcj4KICAgICAgICAgIDxhdXRob3I+CiAgICAgICAgICAgIDxmaXJzdG5hbWU+QW5kcmVhczwvZmlyc3RuYW1lPgogICAgICAgICAgICA8c3VybmFtZT5Nb2hyPC9zdXJuYW1lPgogICAgICAgICAgICA8YWZmaWxpYXRpb24+CiAgICAgIAk8YWRkcmVzcz48ZW1haWw+JmVtYWlsLWFuZHJlYXMtbW9ocjs8L2VtYWlsPjwvYWRkcmVzcz4KICAgICAgICAgICAgPC9hZmZpbGlhdGlvbj4KICAgICAgICAgICAgPGNvbnRyaWI+SmFuIDI1IDIwMDA8L2NvbnRyaWI+CiAgICAgICAgICA8L2F1dGhvcj4KICAgICAgICA8L2F1dGhvcmdyb3VwPgogICAgICA8L3NlY3QyaW5mbz4KCiAgICAgIDx0aXRsZT5Ecml2ZSBsYWJlbHMgYW5kIHNlcmlhbCBudW1iZXJzPC90aXRsZT4KICAgICAgPHBhcmE+CiAgICAgICAgV3JpdHRlbiBieSAmbmFtZS1wZXRyLXRvbWFzZWs7IDxlbWFpbD4mZW1haWwtcGV0ci10b21hc2VrOzwvZW1haWw+CiAgICAgICAgTm92IDE0IDE5OTkKICAgICAgPC9wYXJhPgogICAgICA8cGFyYT4KICAgICAgICBDaGFuZ2VzIGJ5ICZuYW1lLWFuZHJlYXMtbW9ocjsgPGVtYWlsPiZlbWFpbC1hbmRyZWFzLW1vaHI7PC9lbWFpbD4KICAgICAgICBKYW4gMjUgMjAwMAogICAgICA8L3BhcmE+CiAgICAgIDxwYXJhPgogICAgICAgIChFeHRyYWN0ZWQgZnJvbSA8ZmlsZW5hbWU+d2luZS9kb2N1bWVudGF0aW9uL2Nkcm9tLWxhYmVsczwvZmlsZW5hbWU+KQogICAgICA8L3BhcmE+CiAgICAgIDxwYXJhPgogICAgICAgIFVudGlsIG5vdywgeW91ciBvbmx5IHBvc3NpYmlsaXR5IG9mIHNwZWNpZnlpbmcgZHJpdmUgdm9sdW1lCiAgICAgICAgbGFiZWxzIGFuZCBzZXJpYWwgbnVtYmVycyB3YXMgdG8gc2V0IHRoZW0gbWFudWFsbHkgaW4gdGhlIHdpbmUKICAgICAgICBjb25maWd1cmF0aW9uIGZpbGUuIEJ5IG5vdywgd2luZSBjYW4gcmVhZCB0aGVtIGRpcmVjdGx5IGZyb20gdGhlCiAgICAgICAgZGV2aWNlIGFzIHdlbGwuIFRoaXMgbWF5IGJlIHVzZWZ1bCBmb3IgbWFueSBXaW4gOXggZ2FtZXMgb3IKICAgICAgICBmb3Igc2V0dXAgcHJvZ3JhbXMgZGlzdHJpYnV0ZWQgb24gQ0QtUk9NcyB0aGF0IGNoZWNrIGZvcgogICAgICAgIHZvbHVtZSBsYWJlbC4KICAgICAgPC9wYXJhPgoKICAgICAgPHNlY3QzPgogICAgICAgIDx0aXRsZT5XaGF0J3MgU3VwcG9ydGVkPzwvdGl0bGU+CgogICAgICAgIDxpbmZvcm1hbHRhYmxlIGZyYW1lPSJhbGwiPgogICAgICAgICAgPHRncm91cCBjb2xzPSIzIj4KICAgICAgICAgICAgPHRoZWFkPgogICAgICAJPHJvdz4KICAgICAgCSAgPGVudHJ5PkZpbGUgU3lzdGVtPC9lbnRyeT4KICAgICAgCSAgPGVudHJ5PlR5cGVzPC9lbnRyeT4KICAgICAgCSAgPGVudHJ5PkNvbW1lbnQ8L2VudHJ5PgogICAgICAJPC9yb3c+CiAgICAgICAgICAgIDwvdGhlYWQ+CiAgICAgICAgICAgIDx0Ym9keT4KICAgICAgCTxyb3c+CiAgICAgIAkgIDxlbnRyeT5GQVQgc3lzdGVtczwvZW50cnk+CiAgICAgIAkgIDxlbnRyeT5oZCwgZmxvcHB5PC9lbnRyeT4KICAgICAgCSAgPGVudHJ5PnJlYWRzIGxhYmVscyBhbmQgc2VyaWFsIG51bWJlcnM8L2VudHJ5PgogICAgICAJPC9yb3c+CiAgICAgIAk8cm93PgogICAgICAJICA8ZW50cnk+SVNPOTY2MDwvZW50cnk+CiAgICAgIAkgIDxlbnRyeT5jZHJvbTwvZW50cnk+CiAgICAgIAkgIDxlbnRyeT5yZWFkcyBsYWJlbHMgYW5kIHNlcmlhbCBudW1iZXJzIChub3QgbWl4ZWQtbW9kZSBDRHMgeWV0ISk8L2VudHJ5PgogICAgICAJPC9yb3c+CiAgICAgICAgICAgIDwvdGJvZHk+CiAgICAgICAgICA8L3Rncm91cD4KICAgICAgICA8L2luZm9ybWFsdGFibGU+CgogICAgICA8L3NlY3QzPgoKICAgICAgPHNlY3QzPgogICAgICAgIDx0aXRsZT5Ib3cgVG8gU2V0IFVwPzwvdGl0bGU+CiAgICAgICAgPHBhcmE+CiAgICAgICAgICBSZWFkaW5nIGxhYmVscyBhbmQgc2VyaWFsIG51bWJlcnMganVzdCB3b3JrcyBhdXRvbWFnaWNhbGx5CiAgICAgICAgICBpZiB5b3Ugc3BlY2lmeSBhIDxsaXRlcmFsPiJEZXZpY2UiID08L2xpdGVyYWw+IGxpbmUgaW4gdGhlCiAgICAgICAgICBbRHJpdmUgeF0gc2VjdGlvbiBpbiB5b3VyIDxmaWxlbmFtZT5+Ly53aW5lL2NvbmZpZzwvZmlsZW5hbWU+LgogICAgICAgICAgTm90ZSB0aGF0IHRoZSBkZXZpY2UgaGFzIHRvIGV4aXN0IGFuZCBtdXN0IGJlIGFjY2Vzc2libGUgYnkgdGhlIHVzZXIKICAgICAgICAgIHJ1bm5pbmcgV2luZSBpZiB5b3UgZG8gdGhpcywgdGhvdWdoLgogICAgICAgIDwvcGFyYT4KICAgICAgICA8cGFyYT4KICAgICAgICAgIElmIHlvdSBkb24ndCB3YW50IHRvIHJlYWQgbGFiZWxzIGFuZCBzZXJpYWwgbnVtYmVycyBkaXJlY3RseSBmcm9tCiAgICAgICAgICB0aGUgZGV2aWNlLCB0aGVuIHlvdSBzaG91bGQgZ2l2ZSBmaXhlZAogICAgICAgICAgPGxpdGVyYWw+IkxhYmVsIiA9PC9saXRlcmFsPiBvciA8bGl0ZXJhbD4iU2VyaWFsIiA9PC9saXRlcmFsPgogICAgICAgICAgZW50cmllcyBpbiA8ZmlsZW5hbWU+fi8ud2luZS9jb25maWc8L2ZpbGVuYW1lPiwgYXMgV2luZSByZXR1cm5zCiAgICAgICAgICB0aGVzZSBlbnRyaWVzIGluc3RlYWQgaWYgbm8gZGV2aWNlIGlzIGdpdmVuLiBJZiB0aGV5IGRvbid0CiAgICAgICAgICBleGlzdCwgdGhlbiBXaW5lIHdpbGwgcmV0dXJuIGRlZmF1bHQgdmFsdWVzIChsYWJlbAogICAgICAgICAgPGxpdGVyYWw+RHJpdmUgWDwvbGl0ZXJhbD4gYW5kIHNlcmlhbAogICAgICAgICAgPGxpdGVyYWw+MTIzNDU2Nzg8L2xpdGVyYWw+KS4KICAgICAgICA8L3BhcmE+CiAgICAgICAgPHBhcmE+CiAgICAgICAgICBJZiB5b3Ugd2FudCB0byBnaXZlIGEgPGxpdGVyYWw+IkRldmljZSIgPTwvbGl0ZXJhbD4gZW50cnkKICAgICAgICAgIDxlbXBoYXNpcz5vbmx5PC9lbXBoYXNpcz4gZm9yIGRyaXZlIHJhdyBzZWN0b3IgYWNjZXNzZXMsCiAgICAgICAgYnV0IG5vdCBmb3IgcmVhZGluZyB0aGUgdm9sdW1lIGluZm8gZnJvbSB0aGUgZGV2aWNlIChpLmUuIHlvdSB3YW50CiAgICAgICAgYSA8ZW1waGFzaXM+Zml4ZWQ8L2VtcGhhc2lzPiwgcHJlY29uZmlndXJlZCBsYWJlbCksIHlvdSBuZWVkCiAgICAgICAgICB0byBzcGVjaWZ5IDxsaXRlcmFsPiJSZWFkVm9sSW5mbyIgPSAiMCI8L2xpdGVyYWw+IHRvIHRlbGwgV2luZQogICAgICAgICAgdG8gc2tpcCB0aGUgdm9sdW1lIHJlYWRpbmcuCiAgICAgICAgPC9wYXJhPgogICAgICA8L3NlY3QzPgoKICAgICAgPHNlY3QzPgogICAgICAgIDx0aXRsZT5FeGFtcGxlczwvdGl0bGU+CiAgICAgICAgPHBhcmE+CiAgICAgICAgICBIZXJlJ3MgYSBzaW1wbGUgZXhhbXBsZSBvZiBDRC1ST00gYW5kIGZsb3BweTsgbGFiZWxzIHdpbGwgYmUKICAgICAgICAgIHJlYWQgZnJvbSB0aGUgZGV2aWNlIG9uIGJvdGggQ0QtUk9NIGFuZCBmbG9wcHk7IHNlcmlhbAogICAgICAgICAgbnVtYmVycyBvbiBmbG9wcHkgb25seToKICAgICAgICA8L3BhcmE+CiAgICAgICAgPHNjcmVlbj4KICAgICAgW0RyaXZlIEFdCiAgICAgICJQYXRoIiA9ICIvbW50L2Zsb3BweSIKICAgICAgIlR5cGUiID0gImZsb3BweSIKICAgICAgIkRldmljZSIgPSAiL2Rldi9mZDAiCiAgICAgICJGaWxlc3lzdGVtIiA9ICJtc2RvcyIKCiAgICAgIFtEcml2ZSBSXQogICAgICAiUGF0aCIgPSAiL21udC9jZHJvbSIKICAgICAgIlR5cGUiID0gImNkcm9tIgogICAgICAiRGV2aWNlIiA9ICIvZGV2L2hkYTEiCiAgICAgICJGaWxlc3lzdGVtIiA9ICJ3aW45NSIKICAgICAgICA8L3NjcmVlbj4KICAgICAgICA8cGFyYT4KICAgICAgICAgIEhlcmUncyBhbiBleGFtcGxlIG9mIG92ZXJyaWRpbmcgdGhlIENELVJPTSBsYWJlbDoKICAgICAgICA8L3BhcmE+CiAgICAgICAgPHNjcmVlbj4KICAgICAgW0RyaXZlIEpdCiAgICAgICJQYXRoIiA9ICIvbW50L2Nkcm9tIgogICAgICAiVHlwZSIgPSAiY2Ryb20iCiAgICAgICJMYWJlbCIgPSAiWDIzNEdDRFNFIgogICAgICA7IG5vdGUgdGhhdCB0aGUgZGV2aWNlIGlzbid0IHJlYWxseSBuZWVkZWQgaGVyZSBhcyB3ZSBoYXZlIGEgZml4ZWQgbGFiZWwKICAgICAgIkRldmljZSIgPSAiL2Rldi9jZHJvbSIKICAgICAgIkZpbGVzeXN0ZW0iID0gIm1zZG9zIgogICAgICAgIDwvc2NyZWVuPgogICAgICA8L3NlY3QzPgoKICAgICAgPHNlY3QzPgogICAgICAgIDx0aXRsZT5Ub2RvIC8gT3BlbiBJc3N1ZXM8L3RpdGxlPgogICAgICAgIDxpdGVtaXplZGxpc3Q+CiAgICAgICAgICA8bGlzdGl0ZW0+IDxwYXJhPgogICAgICAJVGhlIENELVJPTSBsYWJlbCBjYW4gYmUgcmVhZCBvbmx5IGlmIHRoZSBkYXRhIHRyYWNrIG9mCiAgICAgIAl0aGUgZGlzayByZXNpZGVzIGluIHRoZSBmaXJzdCB0cmFjayBhbmQgdGhlIGNkcm9tIGlzCiAgICAgIAlpc285NjYwLgogICAgICAgICAgICA8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICAgICAgICA8bGlzdGl0ZW0+IDxwYXJhPgogICAgICAJQmV0dGVyIGNoZWNraW5nIGZvciBGQVQgc3VwZXJibG9jayAoaXQgbm93IGNoZWNrcyBvbmx5CiAgICAgIAlvbmUgYnl0ZSkuIDwvcGFyYT4KICAgICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgICAgICA8bGlzdGl0ZW0+IDxwYXJhPgogICAgICAJU3VwcG9ydCBmb3IgbGFiZWxzL3NlcmlhbCBudW1zIFdSSVRJTkcuCiAgICAgICAgICAgIDwvcGFyYT4gPC9saXN0aXRlbT4KICAgICAgICAgIDxsaXN0aXRlbT4gPHBhcmE+CiAgICAgIAlDYW4gdGhlIGxhYmVsIGJlIGxvbmdlciB0aGFuIDExIGNoYXJzPyAoaXNvOTY2MCBoYXMgMzIKICAgICAgCWNoYXJzKS4KICAgICAgICAgICAgPC9wYXJhPiA8L2xpc3RpdGVtPgogICAgICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KICAgICAgCVdoYXQgYWJvdXQgcmVhZGluZyBleHQyIHZvbHVtZSBsYWJlbD8gLi4uLgogICAgICAgICAgICA8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICAgICAgPC9pdGVtaXplZGxpc3Q+CiAgICAgIDwvc2VjdDM+CiAgICA8L3NlY3QyPgogIDwvc2VjdDE+CgogICZyZWdpc3RyeTsKCjxzZWN0MSBpZD0iY29uZmlnLWRsbCI+Cjx0aXRsZT5ETEwgY29uZmlndXJhdGlvbjwvdGl0bGU+Cgo8c2VjdDI+Cjx0aXRsZT5JbnRyb2R1Y3Rpb248L3RpdGxlPgo8cGFyYT4KICBJZiB5b3VyIHByb2dyYW1zIGRvbid0IHdvcmsgYXMgZXhwZWN0ZWQsIHRoZW4gaXQncyBvZnRlbiBiZWNhdXNlIG9uZQogIERMTCBvciBhbm90aGVyIGlzIGZhaWxpbmcuIFRoaXMgY2FuIG9mdGVuIGJlIHJlc29sdmVkIGJ5IGNoYW5naW5nCiAgY2VydGFpbiBETExzIGZyb20gV2luZSBidWlsdC1pbiB0byBuYXRpdmUgV2luZG93cyBETEwgZmlsZSBhbmQgdmljZQogIHZlcnNhLgo8L3BhcmE+CjxwYXJhPgogIEEgdmVyeSB1c2VmdWwgaGVscCB0byBmaW5kIG91dCB3aGljaCBETExzIGFyZSBsb2FkZWQgYXMgYnVpbHQtaW4gYW5kCiAgd2hpY2ggYXJlIGxvYWRlZCBhcyBuYXRpdmUgV2luZG93cyBmaWxlIGNhbiBiZSB0aGUgZGVidWcgY2hhbm5lbAogIGxvYWRkbGwsIGFjdGl2YXRlZCB2aWEgdGhlIFdpbmUgY29tbWFuZCBsaW5lIHBhcmFtZXRlcgogIDxjb21tYW5kPi0tZGVidWdtc2cgK2xvYWRkbGw8L2NvbW1hbmQ+Lgo8L3BhcmE+Cjwvc2VjdDI+Cgo8c2VjdDI+CjwhLS0gRklYTUUgaW50cm8hISEgLS0+Cjx0aXRsZT5JbnRyb2R1Y3Rpb24gVG8gRExMIFNlY3Rpb25zPC90aXRsZT4KPHBhcmE+CiAgVGhlcmUgYXJlIGEgZmV3IHRoaW5ncyB5b3Ugd2lsbCBuZWVkIHRvIGtub3cgYmVmb3JlCiAgY29uZmlndXJpbmcgdGhlIERMTCBzZWN0aW9ucyBpbiB5b3VyIHdpbmUgY29uZmlndXJhdGlvbgogIGZpbGUuCjwvcGFyYT4KPHNlY3QzPgogIDx0aXRsZT5XaW5kb3dzIERMTCBQYWlyczwvdGl0bGU+CiAgPHBhcmE+CiAgICBNb3N0IHdpbmRvd3MgRExMJ3MgaGF2ZSBhIHdpbjE2IChXaW5kb3dzIDMueCkgYW5kIHdpbjMyCiAgICAoV2luZG93cyA5eC9OVCkgZm9ybS4gIFRoZSBjb21iaW5hdGlvbiBvZiB0aGUgd2luMTYgYW5kCiAgICB3aW4zMiBETEwgdmVyc2lvbnMgYXJlIGNhbGxlZCB0aGUgIkRMTCBwYWlyIi4gVGhpcyBpcyBhCiAgICBsaXN0IG9mIHRoZSBtb3N0IGNvbW1vbiBwYWlyczoKICA8L3BhcmE+CgogIDxpbmZvcm1hbHRhYmxlPgogICAgPHRncm91cCBjb2xzPSIzIj4KICAgICAgPHRoZWFkPgoJPHJvdz4KCSAgPGVudHJ5PldpbjE2PC9lbnRyeT4KCSAgPGVudHJ5PldpbjMyPC9lbnRyeT4KCSAgPGVudHJ5PgoJICAgIE5hdGl2ZQoJICAgIDxmb290bm90ZT4KCSAgICAgIDxwYXJhPgoJCUlzIGl0IHBvc3NpYmxlIHRvIHVzZSBuYXRpdmUgRExMIHdpdGggd2luZT8KCQkoU2VlIG5leHQgc2VjdGlvbikKCSAgICAgIDwvcGFyYT4KCSAgICA8L2Zvb3Rub3RlPgoJICA8L2VudHJ5PgoJPC9yb3c+CiAgICAgIDwvdGhlYWQ+CiAgICAgIDx0Ym9keT4KCTxyb3c+CgkgIDxlbnRyeT5LRVJORUw8L2VudHJ5PgoJICA8ZW50cnk+S0VSTkVMMzI8L2VudHJ5PgoJICA8ZW50cnk+Tm8hPC9lbnRyeT4KCTwvcm93PgoJPHJvdz4KCSAgPGVudHJ5PlVTRVI8L2VudHJ5PgoJICA8ZW50cnk+VVNFUjMyPC9lbnRyeT4KCSAgPGVudHJ5Pk5vITwvZW50cnk+Cgk8L3Jvdz4KCTxyb3c+CgkgIDxlbnRyeT5TSEVMTDwvZW50cnk+CgkgIDxlbnRyeT5TSEVMTDMyPC9lbnRyeT4KCSAgPGVudHJ5PlllczwvZW50cnk+Cgk8L3Jvdz4KCTxyb3c+CgkgIDxlbnRyeT5HREk8L2VudHJ5PgoJICA8ZW50cnk+R0RJMzI8L2VudHJ5PgoJICA8ZW50cnk+Tm8hPC9lbnRyeT4KCTwvcm93PgoJPHJvdz4KCSAgPGVudHJ5PkNPTU1ETEc8L2VudHJ5PgoJICA8ZW50cnk+Q09NRExHMzI8L2VudHJ5PgoJICA8ZW50cnk+WWVzPC9lbnRyeT4KCTwvcm93PgoJPHJvdz4KCSAgPGVudHJ5PlZFUjwvZW50cnk+CgkgIDxlbnRyeT5WRVJTSU9OPC9lbnRyeT4KCSAgPGVudHJ5PlllczwvZW50cnk+Cgk8L3Jvdz4KICAgICAgPC90Ym9keT4KICAgIDwvdGdyb3VwPgogIDwvaW5mb3JtYWx0YWJsZT4KPC9zZWN0Mz4KCjxzZWN0Mz4KICA8dGl0bGU+RGlmZmVyZW50IEZvcm1zIE9mIERMTCdzPC90aXRsZT4KICA8cGFyYT4KICAgIFRoZXJlIGFyZSBhIGZldyBkaWZmZXJlbnQgZm9ybXMgb2YgRExMJ3Mgd2luZSBjYW4gbG9hZDoKICAgIDx2YXJpYWJsZWxpc3Q+CiAgICAgIDx2YXJsaXN0ZW50cnk+Cgk8dGVybT5uYXRpdmU8L3Rlcm0+Cgk8bGlzdGl0ZW0+PHBhcmE+CgkgICAgVGhlIERMTCdzIHRoYXQgYXJlIGluY2x1ZGVkIHdpdGggd2luZG93cy4gTWFueQoJICAgIHdpbmRvd3MgRExMJ3MgY2FuIGJlIGxvYWRlZCBpbiB0aGVpciBuYXRpdmUKCSAgICBmb3JtLiBNYW55IHRpbWVzIHRoZXNlIG5hdGl2ZSB2ZXJzaW9ucyB3b3JrCgkgICAgYmV0dGVyIHRoYW4gdGhlaXIgbm9uLU1pY3Jvc29mdCBlcXVpdmFsZW50IC0tCgkgICAgb3RoZXIgdGltZXMgdGhleSBkb24ndC4KCSAgPC9wYXJhPjwvbGlzdGl0ZW0+CiAgICAgIDwvdmFybGlzdGVudHJ5PgogICAgICA8dmFybGlzdGVudHJ5PgoJPHRlcm0+YnVpbHRpbjwvdGVybT4KCTxsaXN0aXRlbT48cGFyYT4KCSAgICBUaGUgbW9zdCBjb21tb24gZm9ybSBvZiBETEwgbG9hZGluZy4gVGhpcyBpcwoJICAgIHdoYXQgeW91IHdpbGwgdXNlIGlmIHRoZSBETEwgaXMgdG9vIHN5c3RlbS1zcGVjaWZpYwoJICAgICAgb3IgZXJyb3ItcHJvbmUgaW4gbmF0aXZlIGZvcm0gKEtFUk5FTCBmb3IgZXhhbXBsZSksCgkgICAgICB5b3UgZG9uJ3QgaGF2ZSB0aGUgbmF0aXZlIERMTCwgb3IgeW91IGp1c3Qgd2FudCB0byBiZQoJICAgIE1pY3Jvc29mdC1mcmVlLgoJICA8L3BhcmE+PC9saXN0aXRlbT4KICAgICAgPC92YXJsaXN0ZW50cnk+CiAgICAgIDx2YXJsaXN0ZW50cnk+Cgk8dGVybT5zbzwvdGVybT4KCTxsaXN0aXRlbT48cGFyYT4KCSAgICBOYXRpdmUgRUxGIGxpYnJhcmllcy4gSGFzIGJlZW4gZGVwcmVjYXRlZCwgaWdub3JlZC4KCSAgPC9wYXJhPjwvbGlzdGl0ZW0+CiAgICAgIDwvdmFybGlzdGVudHJ5PgogICAgICA8dmFybGlzdGVudHJ5PgoJPHRlcm0+ZWxmZGxsPC90ZXJtPgoJPGxpc3RpdGVtPjxwYXJhPgoJICAgIEVMRiBlbmNhcHN1bGF0ZWQgd2luZG93cyBETEwncy4KCSAgICAgIE5vIGxvbmdlciB1c2VkLCBpZ25vcmVkLgoJICA8L3BhcmE+PC9saXN0aXRlbT4KICAgICAgPC92YXJsaXN0ZW50cnk+CiAgICA8L3ZhcmlhYmxlbGlzdD4KICA8L3BhcmE+Cjwvc2VjdDM+Cjwvc2VjdDI+Cgo8c2VjdDIgaWQ9ImNvbmZpZy1kbGwtb3ZlcnJpZGVzIj4KPHRpdGxlPkRMTCBPdmVycmlkZXM8L3RpdGxlPgoKPHBhcmE+CiAgV3JpdHRlbiBieSAmbmFtZS1vdmUta2FhdmVuOyA8ZW1haWw+JmVtYWlsLW92ZS1rYWF2ZW47PC9lbWFpbD4KPC9wYXJhPgo8cGFyYT4KICAoRXh0cmFjdGVkIGZyb20gPGZpbGVuYW1lPndpbmUvZG9jdW1lbnRhdGlvbi9kbGwtb3ZlcnJpZGVzPC9maWxlbmFtZT4pCjwvcGFyYT4KCjxwYXJhPgogIFRoZSB3aW5lIGNvbmZpZ3VyYXRpb24gZmlsZSBkaXJlY3RpdmVzIFtEbGxEZWZhdWx0c10KICBhbmQgW0RsbE92ZXJyaWRlc10gYXJlIHRoZSBzdWJqZWN0IG9mIHNvbWUgY29uZnVzaW9uLiBUaGUKICBvdmVyYWxsIHB1cnBvc2Ugb2YgbW9zdCBvZiB0aGVzZSBkaXJlY3RpdmVzIGFyZSBjbGVhciBlbm91Z2gsCiAgdGhvdWdoIC0gZ2l2ZW4gYSBjaG9pY2UsIHNob3VsZCBXaW5lIHVzZSBpdHMgb3duIGJ1aWx0LWluCiAgRExMcywgb3Igc2hvdWxkIGl0IHVzZSA8ZmlsZW5hbWU+LkRMTDwvZmlsZW5hbWU+IGZpbGVzIGZvdW5kCiAgaW4gYW4gZXhpc3RpbmcgV2luZG93cyBpbnN0YWxsYXRpb24/IFRoaXMgZG9jdW1lbnQgZXhwbGFpbnMKICBob3cgdGhpcyBmZWF0dXJlIHdvcmtzLgo8L3BhcmE+Cgo8c2VjdDM+CiAgPHRpdGxlPkRMTCB0eXBlczwvdGl0bGU+CiAgPHZhcmlhYmxlbGlzdD4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPm5hdGl2ZTwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgQSAibmF0aXZlIiBETEwgaXMgYSA8ZmlsZW5hbWU+LkRMTDwvZmlsZW5hbWU+IGZpbGUKCSAgd3JpdHRlbiBmb3IgdGhlIHJlYWwgTWljcm9zb2Z0IFdpbmRvd3MuCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPmJ1aWx0aW48L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4gPHBhcmE+CgkgIEEgImJ1aWx0LWluIiBETEwgaXMgYSBXaW5lIERMTC4gVGhlc2UgY2FuIGVpdGhlciBiZSBhCgkgIHBhcnQgb2YgPGZpbGVuYW1lPmxpYndpbmUuc288L2ZpbGVuYW1lPiwgb3IgbW9yZQoJICByZWNlbnRseSwgaW4gYSBzcGVjaWFsIDxmaWxlbmFtZT4uc288L2ZpbGVuYW1lPiBmaWxlCgkgIHRoYXQgV2luZSBpcyBhYmxlIHRvIGxvYWQgb24gZGVtYW5kLgoJPC9wYXJhPiA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgPC92YXJpYWJsZWxpc3Q+Cjwvc2VjdDM+Cgo8c2VjdDM+CiAgPHRpdGxlPlRoZSBbRGxsRGVmYXVsdHNdIHNlY3Rpb248L3RpdGxlPgogIDx2YXJpYWJsZWxpc3Q+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT5EZWZhdWx0TG9hZE9yZGVyPC90ZXJtPgogICAgICA8bGlzdGl0ZW0+IDxwYXJhPgoJICBUaGlzIHNwZWNpZmllcyBpbiB3aGF0IG9yZGVyIFdpbmUgc2hvdWxkIHNlYXJjaCBmb3IKCSAgYXZhaWxhYmxlIERMTCB0eXBlcywgaWYgdGhlIERMTCBpbiBxdWVzdGlvbiB3YXMgbm90CgkgIGZvdW5kIGluIHRoZSBbRGxsT3ZlcnJpZGVzXSBzZWN0aW9uLgoJPC9wYXJhPiA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgPC92YXJpYWJsZWxpc3Q+Cjwvc2VjdDM+Cgo8c2VjdDM+CiAgPHRpdGxlPlRoZSBbRGxsUGFpcnNdIHNlY3Rpb248L3RpdGxlPgogIDxwYXJhPgogICAgQXQgb25lIHRpbWUsIHRoZXJlIHdhcyBhIHNlY3Rpb24gY2FsbGVkIFtEbGxQYWlyc10gaW4gdGhlCiAgICBkZWZhdWx0IGNvbmZpZ3VyYXRpb24gZmlsZSwgYnV0IHRoaXMgaGFzIGJlZW4gb2Jzb2xldGVkCiAgICBiZWNhdXNlIHRoZSBwYWlyaW5nIGluZm9ybWF0aW9uIGhhcyBub3cgYmVlbiBlbWJlZGRlZCBpbnRvCiAgICBXaW5lIGl0c2VsZi4gKFRoZSBwdXJwb3NlIG9mIHRoaXMgc2VjdGlvbiB3YXMgbWVyZWx5IHRvIGJlCiAgICBhYmxlIHRvIGlzc3VlIHdhcm5pbmdzIGlmIHRoZSB1c2VyIGF0dGVtcHRlZCB0byBwYWlyCiAgICBjb2RlcGVuZGVudCAxNi1iaXQvMzItYml0IERMTHMgb2YgZGlmZmVyZW50IHR5cGVzLikgSWYgeW91CiAgICBzdGlsbCBoYXZlIHRoaXMgaW4geW91ciA8ZmlsZW5hbWU+fi8ud2luZS9jb25maWc8L2ZpbGVuYW1lPiBvcgogICAgPGZpbGVuYW1lPndpbmUuY29uZjwvZmlsZW5hbWU+LCB5b3UgbWF5IHNhZmVseSBkZWxldGUgaXQuCiAgPC9wYXJhPgo8L3NlY3QzPgoKPHNlY3QzPgogIDx0aXRsZT5UaGUgW0RsbE92ZXJyaWRlc10gc2VjdGlvbjwvdGl0bGU+CiAgPHBhcmE+CiAgICBUaGlzIHNlY3Rpb24gc3BlY2lmaWVzIGhvdyB5b3Ugd2FudCBzcGVjaWZpYyBETExzIHRvIGJlCiAgICBoYW5kbGVkLCBpbiBwYXJ0aWN1bGFyIHdoZXRoZXIgeW91IHdhbnQgdG8gdXNlICJuYXRpdmUiIERMTHMKICAgIG9yIG5vdCwgaWYgeW91IGhhdmUgc29tZSBmcm9tIGEgcmVhbCBXaW5kb3dzIGNvbmZpZ3VyYXRpb24uCiAgICBCZWNhdXNlIGJ1aWx0LWlucyBkbyBub3QgbWl4IHNlYW1sZXNzbHkgd2l0aCBuYXRpdmUgRExMcyB5ZXQsCiAgICBjZXJ0YWluIERMTCBkZXBlbmRlbmNpZXMgbWF5IGJlIHByb2JsZW1hdGljLCBidXQgd29ya2Fyb3VuZHMKICAgIGV4aXN0IGluIFdpbmUgZm9yIG1hbnkgcG9wdWxhciBETEwgY29uZmlndXJhdGlvbnMuIEFsc28gc2VlCiAgICBXV04ncyBbMTZdU3RhdHVzIFBhZ2UgdG8gZmlndXJlIG91dCBob3cgd2VsbCB5b3VyIGZhdm9yaXRlCiAgICBETEwgaXMgaW1wbGVtZW50ZWQgaW4gV2luZS4KICA8L3BhcmE+CiAgPHBhcmE+CiAgICBJdCBpcyBvZiBjb3Vyc2UgYWxzbyBwb3NzaWJsZSB0byBvdmVycmlkZSB0aGVzZSBzZXR0aW5ncyBieQogICAgZXhwbGljdGx5IHVzaW5nIFdpbmUncyA8cGFyYW1ldGVyPi0tZGxsPC9wYXJhbWV0ZXI+CiAgICBjb21tYW5kLWxpbmUgb3B0aW9uIChzZWUgdGhlIG1hbiBwYWdlIGZvciBkZXRhaWxzKS4gIFNvbWUKICAgIGhpbnRzIGZvciBjaG9vc2luZyB5b3VyIG9wdGltYWwgY29uZmlndXJhdGlvbiAobGlzdGVkIGJ5CiAgICAxNi8zMi1iaXQgRExMIHBhaXIpOgogIDwvcGFyYT4KICA8dmFyaWFibGVsaXN0PgogICAgPHZhcmxpc3RlbnRyeT4KICAgICAgPHRlcm0+a3JubDM4Niwga2VybmVsMzI8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4gPHBhcmE+CgkgIE5hdGl2ZSB2ZXJzaW9ucyBvZiB0aGVzZSB3aWxsIG5ldmVyIHdvcmssIHNvIGRvbid0IHRyeS4gTGVhdmUKCSAgYXQgPGxpdGVyYWw+YnVpbHRpbjwvbGl0ZXJhbD4uCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPmdkaSwgZ2RpMzI8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4gPHBhcmE+CgkgIEdyYXBoaWNzIERldmljZSBJbnRlcmZhY2UuIE5vIGVmZm9ydCBoYXMgYmVlbiBtYWRlIGF0IHRyeWluZyB0bwoJICBydW4gbmF0aXZlIEdESS4gTGVhdmUgYXQgPGxpdGVyYWw+YnVpbHRpbjwvbGl0ZXJhbD4uCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPnVzZXIsIHVzZXIzMjwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgV2luZG93IG1hbmFnZW1lbnQgYW5kIHN0YW5kYXJkIGNvbnRyb2xzLiBJdCB3YXMKCSAgcG9zc2libGUgdG8gdXNlIFdpbjk1J3MgPGxpdGVyYWw+bmF0aXZlPC9saXRlcmFsPgoJICB2ZXJzaW9ucyBhdCBzb21lIHBvaW50IChpZiBhbGwgb3RoZXIgRExMcyB0aGF0IGRlcGVuZAoJICBvbiBpdCwgc3VjaCBhcyBjb21jdGwzMiBhbmQgY29tZGxnMzIsIHdlcmUgYWxzbyBydW4KCSAgPGxpdGVyYWw+bmF0aXZlPC9saXRlcmFsPikuIEhvd2V2ZXIsIHRoaXMgaXMgbm8gbG9uZ2VyCgkgIHBvc3NpYmxlIGFmdGVyIHRoZSBBZGRyZXNzIFNwYWNlIFNlcGFyYXRpb24sIHNvIGxlYXZlCgkgIGF0IDxsaXRlcmFsPmJ1aWx0aW48L2xpdGVyYWw+LgoJPC9wYXJhPiA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT5udGRsbDwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgTlQga2VybmVsIEFQSS4gQWx0aG91Z2ggYmFkbHkgZG9jdW1lbnRlZCwgdGhlCgkgIDxsaXRlcmFsPm5hdGl2ZTwvbGl0ZXJhbD4gdmVyc2lvbiBvZiB0aGlzIHdpbGwgbmV2ZXIKCSAgd29yay4gTGVhdmUgYXQgPGxpdGVyYWw+YnVpbHRpbjwvbGl0ZXJhbD4uCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPnczMnNrcm5sPC90ZXJtPgogICAgICA8bGlzdGl0ZW0+IDxwYXJhPgoJICBXaW4zMnMgKGZvciBXaW4zLngpLiBUaGUgPGxpdGVyYWw+bmF0aXZlPC9saXRlcmFsPgoJICB2ZXJzaW9uIHdpbGwgcHJvYmFibHkgbmV2ZXIgd29yay4gTGVhdmUgYXQKCSAgPGxpdGVyYWw+YnVpbHRpbjwvbGl0ZXJhbD4uCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPndvdzMyPC90ZXJtPgogICAgICA8bGlzdGl0ZW0+IDxwYXJhPgoJICBXaW4xNiBzdXBwb3J0IGxpYnJhcnkgZm9yIE5ULiBUaGUKCSAgPGxpdGVyYWw+bmF0aXZlPC9saXRlcmFsPiB2ZXJzaW9uIHdpbGwgcHJvYmFibHkgbmV2ZXIKCSAgd29yay4gTGVhdmUgYXQgPGxpdGVyYWw+YnVpbHRpbjwvbGl0ZXJhbD4uCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPnN5c3RlbTwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgV2luMTYga2VybmVsIHN0dWZmLiBXaWxsIG5ldmVyIHdvcmsKCSAgPGxpdGVyYWw+bmF0aXZlPC9saXRlcmFsPi4gTGVhdmUgYXQKCSAgPGxpdGVyYWw+YnVpbHRpbjwvbGl0ZXJhbD4uCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPmRpc3BsYXk8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4gPHBhcmE+CgkgIERpc3BsYXkgZHJpdmVyLiBEZWZpbml0ZWx5IGxlYXZlIGF0IDxsaXRlcmFsPmJ1aWx0aW48L2xpdGVyYWw+LgoJPC9wYXJhPiA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT50b29saGVscDwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgVG9vbCBoZWxwZXIgcm91dGluZXMuIFRoaXMgaXMgcmFyZWx5IGEgc291cmNlIG9mIHByb2JsZW1zLgoJICBMZWF2ZSBhdCA8bGl0ZXJhbD5idWlsdGluPC9saXRlcmFsPi4KCTwvcGFyYT4gPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogICAgPHZhcmxpc3RlbnRyeT4KICAgICAgPHRlcm0+dmVyLCB2ZXJzaW9uPC90ZXJtPgogICAgICA8bGlzdGl0ZW0+IDxwYXJhPgoJICBWZXJzaW9uaW5nLiBTZWxkb20gdXNlZnVsIHRvIG1lc3Mgd2l0aC4KCTwvcGFyYT4gPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogICAgPHZhcmxpc3RlbnRyeT4KICAgICAgPHRlcm0+YWR2YXBpMzI8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4gPHBhcmE+CgkgIFJlZ2lzdHJ5IGFuZCBzZWN1cml0eSBmZWF0dXJlcy4gVHJ5aW5nIHRoZQoJICA8bGl0ZXJhbD5uYXRpdmU8L2xpdGVyYWw+IHZlcnNpb24gb2YgdGhpcyBtYXkgb3IgbWF5CgkgIG5vdCB3b3JrLgoJPC9wYXJhPiA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT5jb21tZGxnLCBjb21kbGczMjwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgQ29tbW9uIERpYWxvZ3MsIHN1Y2ggYXMgY29sb3IgcGlja2VyLCBmb250IGRpYWxvZywKCSAgcHJpbnQgZGlhbG9nLCBvcGVuL3NhdmUgZGlhbG9nLCBldGMuIEl0IGlzIHNhZmUgdG8gdHJ5CgkgIDxsaXRlcmFsPm5hdGl2ZTwvbGl0ZXJhbD4uCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPmNvbW1jdHJsLCBjb21jdGwzMjwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgQ29tbW9uIENvbnRyb2xzLiBUaGlzIGlzIHRvb2xiYXJzLCBzdGF0dXMgYmFycywgbGlzdCBjb250cm9scywKCSAgdGhlIHdvcmtzLiBJdCBpcyBzYWZlIHRvIHRyeSA8bGl0ZXJhbD5uYXRpdmU8L2xpdGVyYWw+LgoJPC9wYXJhPiA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT5zaGVsbCwgc2hlbGwzMjwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgU2hlbGwgaW50ZXJmYWNlIChkZXNrdG9wLCBmaWxlc3lzdGVtLCBldGMpLiBCZWluZyBvbmUgb2YgdGhlCgkgIG1vc3QgdW5kb2N1bWVudGVkIHBpZWNlcyBvZiBXaW5kb3dzLCB5b3UgbWF5IGhhdmUgbHVjayB3aXRoIHRoZQoJICA8bGl0ZXJhbD5uYXRpdmU8L2xpdGVyYWw+IHZlcnNpb24sIHNob3VsZCB5b3UgbmVlZCBpdC4KCTwvcGFyYT4gPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogICAgPHZhcmxpc3RlbnRyeT4KICAgICAgPHRlcm0+d2luc29jaywgd3NvY2szMjwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgV2luZG93cyBTb2NrZXRzLiBUaGUgPGxpdGVyYWw+bmF0aXZlPC9saXRlcmFsPiB2ZXJzaW9uCgkgIHdpbGwgbm90IHdvcmsgdW5kZXIgV2luZSwgc28gbGVhdmUgYXQKCSAgPGxpdGVyYWw+YnVpbHRpbjwvbGl0ZXJhbD4uCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPmljbXA8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4gPHBhcmE+CgkgIElDTVAgcm91dGluZXMgZm9yIHdzb2NrMzIuIEFzIHdpdGggd3NvY2szMiwgbGVhdmUgYXQKCSAgPGxpdGVyYWw+YnVpbHRpbjwvbGl0ZXJhbD4uCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPm1wcjwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgVGhlIDxsaXRlcmFsPm5hdGl2ZTwvbGl0ZXJhbD4gdmVyc2lvbiBtYXkgbm90IHdvcmsgZHVlCgkgIHRvIHRodW5raW5nIGlzc3Vlcy4gTGVhdmUgYXQKCSAgPGxpdGVyYWw+YnVpbHRpbjwvbGl0ZXJhbD4uCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPmx6ZXhwYW5kLCBsejMyPC90ZXJtPgogICAgICA8bGlzdGl0ZW0+IDxwYXJhPgoJICBMZW1wZWwtWml2IGRlY29tcHJlc3Npb24uIFdpbmUncwoJICA8bGl0ZXJhbD5idWlsdGluPC9saXRlcmFsPiB2ZXJzaW9uIG91Z2h0IHRvIHdvcmsgZmluZS4KCTwvcGFyYT4gPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogICAgPHZhcmxpc3RlbnRyeT4KICAgICAgPHRlcm0+d2luYXNwaSwgd25hc3BpMzI8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4gPHBhcmE+CgkgIEFkdmFuY2VkIFNDU0kgUGVyaXBoZXJhbCBJbnRlcmZhY2UuIFRoZQoJICA8bGl0ZXJhbD5uYXRpdmU8L2xpdGVyYWw+IHZlcnNpb24gd2lsbCBwcm9iYWJseSBuZXZlcgoJICB3b3JrLiBMZWF2ZSBhdCA8bGl0ZXJhbD5idWlsdGluPC9saXRlcmFsPi4KCTwvcGFyYT4gPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogICAgPHZhcmxpc3RlbnRyeT4KICAgICAgPHRlcm0+Y3J0ZGxsPC90ZXJtPgogICAgICA8bGlzdGl0ZW0+IDxwYXJhPgoJICBDIFJ1bnRpbWUgbGlicmFyeS4gVGhlIDxsaXRlcmFsPm5hdGl2ZTwvbGl0ZXJhbD4KCSAgdmVyc2lvbiB3aWxsIGVhc2lseSB3b3JrIGJldHRlciB0aGFuIFdpbmUncyBvbiB0aGlzCgkgIG9uZS4KCTwvcGFyYT4gPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogICAgPHZhcmxpc3RlbnRyeT4KICAgICAgPHRlcm0+d2luc3Bvb2wuZHJ2PC90ZXJtPgogICAgICA8bGlzdGl0ZW0+IDxwYXJhPgoJICBQcmludGVyIHNwb29sZXIuIFlvdSBhcmUgbm90IGxpa2VseSB0byBoYXZlIG1vcmUgbHVjawoJICB3aXRoIHRoZSA8bGl0ZXJhbD5uYXRpdmU8L2xpdGVyYWw+IHZlcnNpb24uCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPmRkcmF3PC90ZXJtPgogICAgICA8bGlzdGl0ZW0+IDxwYXJhPgoJICBEaXJlY3REcmF3L0RpcmVjdDNELiBTaW5jZSBXaW5lIGRvZXMgbm90IGltcGxlbWVudCB0aGUKCSAgRGlyZWN0WCBIQUwsIHRoZSA8bGl0ZXJhbD5uYXRpdmU8L2xpdGVyYWw+IHZlcnNpb24KCSAgd2lsbCBub3Qgd29yayBhdCB0aGlzIHRpbWUuCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPmRpbnB1dDwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgRGlyZWN0SW5wdXQuIFJ1bm5pbmcgdGhpcyA8bGl0ZXJhbD5uYXRpdmU8L2xpdGVyYWw+CgkgIG1heSBvciBtYXkgbm90IHdvcmsuCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPmRzb3VuZDwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgRGlyZWN0U291bmQuIEl0IG1heSBiZSBwb3NzaWJsZSB0byBydW4gdGhpcwoJICA8bGl0ZXJhbD5uYXRpdmU8L2xpdGVyYWw+LCBidXQgZG9uJ3QgY291bnQgb24gaXQuCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPmRwbGF5L2RwbGF5eDwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgRGlyZWN0UGxheS4gVGhlIDxsaXRlcmFsPm5hdGl2ZTwvbGl0ZXJhbD4gdmVyc2lvbgoJICBvdWdodCB0byB3b3JrIGJlc3Qgb24gdGhpcywgaWYgYXQgYWxsLgoJPC9wYXJhPiA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT5tbXN5c3RlbSwgd2lubW08L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4gPHBhcmE+CgkgIE11bHRpbWVkaWEgc3lzdGVtLiBUaGUgPGxpdGVyYWw+bmF0aXZlPC9saXRlcmFsPgoJICB2ZXJzaW9uIGlzIG5vdCBsaWtlbHkgdG8gd29yay4gTGVhdmUgYXQKCSAgPGxpdGVyYWw+YnVpbHRpbjwvbGl0ZXJhbD4uCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPm1zYWNtLCBtc2FjbTMyPC90ZXJtPgogICAgICA8bGlzdGl0ZW0+IDxwYXJhPgoJICBBdWRpbyBDb21wcmVzc2lvbiBNYW5hZ2VyLiBUaGUKCSAgPGxpdGVyYWw+YnVpbHRpbjwvbGl0ZXJhbD4gdmVyc2lvbiB3b3JrcyBiZXN0LCBpZiB5b3UKCSAgc2V0IG1zYWNtLmRydiB0byB0aGUgc2FtZS4KCTwvcGFyYT4gPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogICAgPHZhcmxpc3RlbnRyeT4KICAgICAgPHRlcm0+bXN2aWRlbywgbXN2ZnczMjwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgVmlkZW8gZm9yIFdpbmRvd3MuIEl0IGlzIHNhZmUgKGFuZCByZWNvbW1lbmRlZCkgdG8gdHJ5CgkgIDxsaXRlcmFsPm5hdGl2ZTwvbGl0ZXJhbD4uCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPm1jaWNkYS5kcnY8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4gPHBhcmE+CgkgIENEIEF1ZGlvIE1DSSBkcml2ZXIuCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPm1jaXNlcS5kcnY8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4gPHBhcmE+CgkgIE1JREkgU2VxdWVuY2VyIE1DSSBkcml2ZXIgKDxmaWxlbmFtZT4uTUlEPC9maWxlbmFtZT4KCSAgcGxheWJhY2spLgoJPC9wYXJhPiA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT5tY2l3YXZlLmRydjwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgV2F2ZSBhdWRpbyBNQ0kgZHJpdmVyICg8ZmlsZW5hbWU+LldBVjwvZmlsZW5hbWU+IHBsYXliYWNrKS4KCTwvcGFyYT4gPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogICAgPHZhcmxpc3RlbnRyeT4KICAgICAgPHRlcm0+bWNpYXZpLmRydjwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgQVZJIE1DSSBkcml2ZXIgKDxmaWxlbmFtZT4uQVZJPC9maWxlbmFtZT4gdmlkZW8KCSAgcGxheWJhY2spLiBCZXN0IHRvIHVzZSA8bGl0ZXJhbD5uYXRpdmU8L2xpdGVyYWw+LgoJPC9wYXJhPiA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT5tY2lhbmltLmRydjwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgQW5pbWF0aW9uIE1DSSBkcml2ZXIuCgk8L3BhcmE+IDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPm1zYWNtLmRydjwvdGVybT4KICAgICAgPGxpc3RpdGVtPiA8cGFyYT4KCSAgQXVkaW8gQ29tcHJlc3Npb24gTWFuYWdlci4gU2V0IHRvIHNhbWUgYXMgbXNhY20zMi4KCTwvcGFyYT4gPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogICAgPHZhcmxpc3RlbnRyeT4KICAgICAgPHRlcm0+bWlkaW1hcC5kcnY8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4gPHBhcmE+CgkgIE1JREkgTWFwcGVyLgoJPC9wYXJhPiA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT53cHJvY3M8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4gPHBhcmE+CgkgIFRoaXMgaXMgYSBwc2V1ZG8tRExMIHVzZWQgYnkgV2luZSBmb3IgdGh1bmtpbmcKCSAgcHVycG9zZXMuIEEgPGxpdGVyYWw+bmF0aXZlPC9saXRlcmFsPiB2ZXJzaW9uIG9mIHRoaXMKCSAgZG9lc24ndCBleGlzdC4KCTwvcGFyYT4gPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogIDwvdmFyaWFibGVsaXN0Pgo8L3NlY3QzPgo8L3NlY3QyPgoKPHNlY3QyIGlkPSJjb25maWctc3lzdGVtLWRsbHMiPgo8dGl0bGU+U3lzdGVtIERMTHM8L3RpdGxlPgo8cGFyYT4KICBUaGUgV2luZSB0ZWFtIGhhcyBkZXRlcm1pbmVkIHRoYXQgaXQgaXMgbmVjZXNzYXJ5IHRvIGNyZWF0ZQogIGZha2UgRExMIGZpbGVzIHRvIHRyaWNrIG1hbnkgcHJvZ3JhbXMgdGhhdCBjaGVjayBmb3IKICBmaWxlIGV4aXN0ZW5jZSB0byBkZXRlcm1pbmUgd2hldGhlciBhIHBhcnRpY3VsYXIgZmVhdHVyZQogIChzdWNoIGFzIFdpbnNvY2sgYW5kIGl0cyBUQ1AvSVAgbmV0d29ya2luZykgaXMgYXZhaWxhYmxlLiBJZgogIHRoaXMgaXMgYSBwcm9ibGVtIGZvciB5b3UsIHlvdSBjYW4gY3JlYXRlIGVtcHR5IGZpbGVzIGluIHRoZQogIGNvbmZpZ3VyZWQgPGZpbGVuYW1lPmM6XHdpbmRvd3Ncc3lzdGVtPC9maWxlbmFtZT4gZGlyZWN0b3J5CiAgdG8gbWFrZSB0aGUgcHJvZ3JhbSB0aGluayBpdCdzIHRoZXJlLCBhbmQgV2luZSdzIGJ1aWx0LWluIERMTAogIHdpbGwgYmUgbG9hZGVkIHdoZW4gdGhlIHByb2dyYW0gYWN0dWFsbHkgYXNrcyBmb3IgaXQuCiAgKFVuZm9ydHVuYXRlbHksIDxmaWxlbmFtZT50b29scy93aW5laW5zdGFsbDwvZmlsZW5hbWU+IGRvZXMKICBub3QgY3JlYXRlIHN1Y2ggZW1wdHkgZmlsZXMgaXRzZWxmLikKPC9wYXJhPgo8cGFyYT4KICBBcHBsaWNhdGlvbnMgc29tZXRpbWVzIGFsc28gdHJ5IHRvIGluc3BlY3QgdGhlIHZlcnNpb24KICByZXNvdXJjZXMgZnJvbSB0aGUgcGh5c2ljYWwgZmlsZXMgKGZvciBleGFtcGxlLCB0byBkZXRlcm1pbmUKICB0aGUgRGlyZWN0WCB2ZXJzaW9uKS4gRW1wdHkgZmlsZXMgd2lsbCBub3QgZG8gaW4gdGhpcyBjYXNlLAogIGl0IGlzIHJhdGhlciBuZWNlc3NhcnkgdG8gaW5zdGFsbCBmaWxlcyB3aXRoIGNvbXBsZXRlCiAgdmVyc2lvbiByZXNvdXJjZXMuIFRoaXMgcHJvYmxlbSBpcyBjdXJyZW50bHkgYmVpbmcgd29ya2VkCiAgb24uIEluIHRoZSBtZWFudGltZSwgeW91IG1heSBzdGlsbCBuZWVkIHRvIGdyYWIgc29tZSByZWFsCiAgRExMIGZpbGVzIHRvIGZvb2wgdGhlc2UgYXBwcyB3aXRoLgo8L3BhcmE+CjxwYXJhPgogIEFuZCB0aGVyZSBhcmUgb2YgY291cnNlIERMTHMgdGhhdCB3aW5lIGRvZXMgbm90IGN1cnJlbnRseQogIGltcGxlbWVudCB2ZXJ5IHdlbGwgKG9yIGF0IGFsbCkuIElmIHlvdSBkbyBub3QgaGF2ZSBhIHJlYWwKICBXaW5kb3dzIHlvdSBjYW4gc3RlYWwgbmVjZXNzYXJ5IERMTHMgZnJvbSwgeW91IGNhbiBhbHdheXMKICBnZXQgc29tZSBmcm9tIG9uZSBvZiB0aGUgV2luZG93cyBETEwgYXJjaGl2ZSBzaXRlcwogIHRoYXQgY2FuIGJlIGZvdW5kIHZpYSBpbnRlcm5ldCBzZWFyY2ggZW5naW5lLgogIFBsZWFzZSBtYWtlIHN1cmUgdG8gb2JleSBhbnkgbGljZW5zZXMgb24gdGhlIERMTHMgeW91IGZldGNoLi4uCiAgKHNvbWUgYXJlIHJlZGlzdHJpYnV0YWJsZSwgc29tZSBhcmVuJ3QpLgo8L3BhcmE+Cjwvc2VjdDI+Cgo8c2VjdDIgaWQ9ImNvbmZpZy1kbGwtbWlzc2luZyI+Cjx0aXRsZT5NaXNzaW5nIERMTHM8L3RpdGxlPgoKPHBhcmE+CiAgV3JpdHRlbiBieSAmbmFtZS1hbmRyZWFzLW1vaHI7IDxlbWFpbD4mZW1haWwtYW5kcmVhcy1tb2hyOzwvZW1haWw+CjwvcGFyYT4KCjxwYXJhPgogIEluIGNhc2UgV2luZSBjb21wbGFpbnMgYWJvdXQgYSBtaXNzaW5nIERMTCwgeW91IHNob3VsZCBjaGVjayB3aGV0aGVyCiAgdGhpcyBmaWxlIGlzIGEgcHVibGljbHkgYXZhaWxhYmxlIERMTCBvciBhIGN1c3RvbSBETEwgYmVsb25naW5nCiAgdG8geW91ciBwcm9ncmFtIChieSBzZWFyY2hpbmcgZm9yIGl0cyBuYW1lIG9uIHRoZSBpbnRlcm5ldCkuCiAgSWYgeW91IG1hbmFnZWQgdG8gZ2V0IGhvbGQgb2YgdGhlIERMTCwgdGhlbiB5b3Ugc2hvdWxkIG1ha2Ugc3VyZQogIHRoYXQgV2luZSBpcyBhYmxlIHRvIGZpbmQgYW5kIGxvYWQgaXQuCiAgRExMcyB1c3VhbGx5IGdldCBsb2FkZWQgYWNjb3JkaW5nIHRvIHRoZSBtZWNoYW5pc20gb2YgdGhlCiAgU2VhcmNoUGF0aCgpIGZ1bmN0aW9uLgogIFRoaXMgZnVuY3Rpb24gc2VhcmNoZXMgZGlyZWN0b3JpZXMgaW4gdGhlIGZvbGxvd2luZyBvcmRlcjoKCiAgPG9yZGVyZWRsaXN0PgogICAgPGxpc3RpdGVtPgogICAgICA8cGFyYT4KCVRoZSBkaXJlY3RvcnkgdGhlIHByb2dyYW0gd2FzIHN0YXJ0ZWQgZnJvbS4KICAgICAgPC9wYXJhPgogICAgPC9saXN0aXRlbT4KICAgIDxsaXN0aXRlbT4KICAgICAgPHBhcmE+CglUaGUgY3VycmVudCBkaXJlY3RvcnkuCiAgICAgIDwvcGFyYT4KICAgIDwvbGlzdGl0ZW0+CiAgICA8bGlzdGl0ZW0+CiAgICAgIDxwYXJhPgoJVGhlIFdpbmRvd3Mgc3lzdGVtIGRpcmVjdG9yeS4KICAgICAgPC9wYXJhPgogICAgPC9saXN0aXRlbT4KICAgIDxsaXN0aXRlbT4KICAgICAgPHBhcmE+CglUaGUgV2luZG93cyBkaXJlY3RvcnkuCiAgICAgIDwvcGFyYT4KICAgIDwvbGlzdGl0ZW0+CiAgICA8bGlzdGl0ZW0+CiAgICAgIDxwYXJhPgoJVGhlIFBBVEggdmFyaWFibGUgZGlyZWN0b3JpZXMuCiAgICAgIDwvcGFyYT4KICAgIDwvbGlzdGl0ZW0+CiAgPC9vcmRlcmVkbGlzdD4KCiAgSW4gc2hvcnQ6IGVpdGhlciBwdXQgdGhlIHJlcXVpcmVkIERMTCBpbnRvIHlvdXIgcHJvZ3JhbQogIGRpcmVjdG9yeSAobWlnaHQgYmUgdWdseSksIG9yIHVzdWFsbHkgcHV0IGl0IGludG8gdGhlIFdpbmRvd3Mgc3lzdGVtCiAgZGlyZWN0b3J5LiBKdXN0IGZpbmQgb3V0IGl0cyBkaXJlY3RvcnkgYnkgaGF2aW5nIGEgbG9vayBhdCB0aGUgV2luZQogIGNvbmZpZ3VyYXRpb24gZmlsZSB2YXJpYWJsZSAiU3lzdGVtIiAod2hpY2ggaW5kaWNhdGVzIHRoZSBsb2NhdGlvbiBvZiB0aGUKICBXaW5kb3dzIHN5c3RlbSBkaXJlY3RvcnkpIGFuZCB0aGUgYXNzb2NpYXRlZCBkcml2ZSBlbnRyeS4KICBOb3RlIHRoYXQgeW91IHByb2JhYmx5IHNob3VsZG4ndCB1c2UgTlQtYmFzZWQgbmF0aXZlIERMTHMsCiAgc2luY2UgV2luZSdzIE5UIEFQSSBzdXBwb3J0IGlzIHNvbWV3aGF0IHdlYWtlciB0aGFuIGl0cyBXaW45eAogIEFQSSBzdXBwb3J0ICh0aHVzIGxlYWRpbmcgdG8gZXZlbiB3b3JzZSBjb21wYXRpYmlsaXR5IHdpdGggTlQgRExMcwogIHRoYW4gd2l0aCBhIG5vLXdpbmRvd3Mgc2V0dXAhKSwgc28gYmV0dGVyIHVzZSBXaW45eCBuYXRpdmUgRExMcwogIGluc3RlYWQgb3Igbm8gbmF0aXZlIERMTHMgYXQgYWxsLgo8L3BhcmE+Cjwvc2VjdDI+Cgo8c2VjdDIgaWQ9ImNvbmZpZy1kbGwtd2luZG93cyI+Cjx0aXRsZT5GZXRjaGluZyBuYXRpdmUgRExMcyBmcm9tIGEgV2luZG93cyBDRDwvdGl0bGU+Cgo8cGFyYT4KICBXcml0dGVuIGJ5ICZuYW1lLWFuZHJlYXMtbW9ocjsgPGVtYWlsPiZlbWFpbC1hbmRyZWFzLW1vaHI7PC9lbWFpbD4KPC9wYXJhPgoKPHBhcmE+ClRoZSBMaW51eCA8Y29tbWFuZD5jYWJleHRyYWN0PC9jb21tYW5kPiB1dGlsaXR5IGNhbiBiZSB1c2VkIHRvCmV4dHJhY3QgbmF0aXZlIFdpbmRvd3MgLmRsbCBmaWxlcyBmcm9tIC5jYWIgZmlsZXMgdGhhdCBhcmUgdG8gYmUKZm91bmQgb24gbWFueSBXaW5kb3dzIGluc3RhbGxhdGlvbiBDRHMuCjwvcGFyYT4KPC9zZWN0Mj4KPC9zZWN0MT4KCjxzZWN0MSBpZD0iY29uZmlnLWdyYXBoaWNzLWRyaXZlciI+Cjx0aXRsZT5Db25maWd1cmluZyB0aGUgZ3JhcGhpY3MgZHJpdmVyICh4MTFkcnYsIHR0eWRydiBldGMuKTwvdGl0bGU+Cgo8cGFyYT4KV2luZSBjdXJyZW50bHkgc3VwcG9ydHMgc2V2ZXJhbCBkaWZmZXJlbnQgZGlzcGxheSBzdWJzeXN0ZW1zCihncmFwaGljcyAvIHRleHQpIHRoYXQgYXJlIGF2YWlsYWJsZSBvbiB2YXJpb3VzIG9wZXJhdGluZwpzeXN0ZW1zIHRvZGF5LgpGb3IgZWFjaCBvZiB0aGVzZSwgV2luZSBpbXBsZW1lbnRzIGl0cyBvd24gaW50ZXJmYWNpbmcgZHJpdmVyLgpUaGlzIHNlY3Rpb24gZXhwbGFpbnMgaG93IHRvIHNlbGVjdCBvbmUgb2YgdGhlc2UgZHJpdmVycwphbmQgaG93IHRvIGZ1cnRoZXIgY29uZmlndXJlIHRoZSByZXNwZWN0aXZlIGRyaXZlci4KT25jZSB5b3UncmUgZmluaXNoZWQgd2l0aCB0aGF0LCB5b3UgY2FuIGNvbnNpZGVyIHlvdXIgV2luZSBpbnN0YWxsYXRpb24KdG8gYmUgZmluaXNoZWQuCjwvcGFyYT4KCjxwYXJhPgpUaGUgZGlzcGxheSBkcml2ZXJzIGN1cnJlbnRseSBpbXBsZW1lbnRlZCBpbiBXaW5lIGFyZToKeDExZHJ2LCB3aGljaCBpcyB1c2VkIGZvciBpbnRlcmZhY2luZyB0byBYMTEgZ3JhcGhpY3MKKHRoZSBvbmUgeW91J2xsIG1vc3QgbGlrZWx5IHdhbnQgdG8gdXNlKSBhbmQgdHR5ZHJ2Cih1c2VkIGZvciB0ZXh0IG1vZGUgY29uc29sZSBhcHBzIG1haW5seSB0aGF0IGRvbid0IHJlYWxseSBuZWVkCmFueSBncmFwaGljcyBvdXRwdXQpLgpPbmNlIHlvdSBoYXZlIGRlY2lkZWQgd2hpY2ggZGlzcGxheSBkcml2ZXIgdG8gdXNlLCBpdCBpcyBjaG9zZW4Kd2l0aCB0aGUgPGxpdGVyYWw+R3JhcGhpY3NEcml2ZXI8L2xpdGVyYWw+IG9wdGlvbiBpbiB0aGUKW3dpbmVdIHNlY3Rpb24gb2YgPGZpbGVuYW1lPn4vLndpbmUvY29uZmlnPC9maWxlbmFtZT4uCjwvcGFyYT4KCjxzZWN0Mj4KPHRpdGxlPkNvbmZpZ3VyaW5nIHRoZSB4MTFkcnYgZ3JhcGhpY3MgZHJpdmVyPC90aXRsZT4KCjxwYXJhPgogIFdyaXR0ZW4gYnkgJm5hbWUtb3ZlLWthYXZlbjsgPGVtYWlsPiZlbWFpbC1vdmUta2FhdmVuOzwvZW1haWw+CjwvcGFyYT4KPHBhcmE+CiAgKEV4dHJhY3RlZCBmcm9tIDxmaWxlbmFtZT53aW5lL2RvY3VtZW50YXRpb24veDExZHJ2PC9maWxlbmFtZT4pCjwvcGFyYT4KCjxzZWN0Mz4KICA8dGl0bGU+eDExZHJ2IG1vZGVzIG9mIG9wZXJhdGlvbjwvdGl0bGU+CgogIDxwYXJhPgogICAgVGhlIHgxMWRydiBkcml2ZXIgY29uc2lzdHMgb2YgdHdvIGNvbmNlcHR1YWxseSBkaXN0aW5jdAogICAgcGllY2VzLCB0aGUgZ3JhcGhpY3MgZHJpdmVyIChHREkgcGFydCksIGFuZCB0aGUgd2luZG93aW5nCiAgICBkcml2ZXIgKFVTRVIgcGFydCkuIEJvdGggb2YgdGhlc2UgYXJlIGxpbmtlZCBpbnRvIHRoZQogICAgPGZpbGVuYW1lPmxpYngxMWRydi5zbzwvZmlsZW5hbWU+IG1vZHVsZSwgdGhvdWdoICh3aGljaCB5b3UKICAgIGxvYWQgd2l0aCB0aGUgPGxpdGVyYWw+R3JhcGhpY3NEcml2ZXI8L2xpdGVyYWw+IG9wdGlvbikuIEluCiAgICBXaW5lLCBydW5uaW5nIG9uIFgxMSwgdGhlIGdyYXBoaWNzIGRyaXZlciBtdXN0IGRyYXcgb24KICAgIGRyYXdhYmxlcyAod2luZG93IGludGVyaW9ycykgcHJvdmlkZWQgYnkgdGhlIHdpbmRvd2luZwogICAgZHJpdmVyLiBUaGlzIGRpZmZlcnMgYSBiaXQgZnJvbSB0aGUgV2luZG93cyBtb2RlbCwgd2hlcmUgdGhlCiAgICB3aW5kb3dpbmcgc3lzdGVtIGNyZWF0ZXMgYW5kIGNvbmZpZ3VyZXMgZGV2aWNlIGNvbnRleHRzCiAgICBjb250cm9sbGVkIGJ5IHRoZSBncmFwaGljcyBkcml2ZXIsIGFuZCBwcm9ncmFtcyBhcmUKICAgIGFsbG93ZWQgdG8gaG9vayBpbnRvIHRoaXMgcmVsYXRpb25zaGlwIGFueXdoZXJlIHRoZXkgbGlrZS4KICAgIFRodXMsIHRvIHByb3ZpZGUgYW55IHJlYXNvbmFibGUgdHJhZGVvZmYgYmV0d2VlbgogICAgY29tcGF0aWJpbGl0eSBhbmQgdXNhYmlsaXR5LCB0aGUgeDExZHJ2IGhhcyB0aHJlZSBkaWZmZXJlbnQKICAgIG1vZGVzIG9mIG9wZXJhdGlvbi4KICA8L3BhcmE+CgogIDx2YXJpYWJsZWxpc3Q+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT5NYW5hZ2VkPC90ZXJtPgogICAgICA8bGlzdGl0ZW0+Cgk8cGFyYT4KCSAgVGhlIGRlZmF1bHQuIFNwZWNpZmllZCBieSB1c2luZyB0aGUgPGxpdGVyYWw+TWFuYWdlZDwvbGl0ZXJhbD4KCSAgd2luZSBjb25maWd1cmF0aW9uIGZpbGUgb3B0aW9uIChzZWUgYmVsb3cpLgoJICBPcmRpbmFyeSB0b3AtbGV2ZWwgZnJhbWUgd2luZG93cyB3aXRoIHRoaWNrIGJvcmRlcnMsCgkgIHRpdGxlIGJhcnMsIGFuZCBzeXN0ZW0gbWVudXMgd2lsbCBiZSBtYW5hZ2VkIGJ5IHlvdXIKCSAgd2luZG93IG1hbmFnZXIuIFRoaXMgbGV0cyB0aGVzZSBwcm9ncmFtcyBpbnRlZ3JhdGUKCSAgYmV0dGVyIHdpdGggdGhlIHJlc3Qgb2YgeW91ciBkZXNrdG9wLCBidXQgbWF5IG5vdAoJICBhbHdheXMgd29yayBwZXJmZWN0bHkgKGEgcmV3cml0ZSBvZiB0aGlzIG1vZGUgb2YKCSAgb3BlcmF0aW9uLCB0byBtYWtlIGl0IG1vcmUgcm9idXN0IGFuZCBsZXNzIHBhdGNoeSwgaXMKCSAgY3VycmVudGx5IGJlaW5nIGRvbmUsIHRob3VnaCwgYW5kIGl0J3MgcGxhbm5lZCB0byBiZQoJICBmaW5pc2hlZCBiZWZvcmUgdGhlIFdpbmUgMS4wIHJlbGVhc2UpLgoJPC9wYXJhPgogICAgICA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT5Vbm1hbmFnZWQgLyBOb3JtYWw8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4KCTxwYXJhPgoJICBXaW5kb3cgbWFuYWdlciBpbmRlcGVuZGVudCAoYW55IHJ1bm5pbmcKCSAgd2luZG93IG1hbmFnZXIgaXMgaWdub3JlZCBjb21wbGV0ZWx5KS4gV2luZG93CgkgIGRlY29yYXRpb25zICh0aXRsZSBiYXJzLCBib3JkZXJzLCBldGMpIGFyZSBkcmF3biBieQoJICBXaW5lIHRvIGxvb2sgYW5kIGZlZWwgbGlrZSB0aGUgcmVhbCBXaW5kb3dzLiBUaGlzIGlzCgkgIGNvbXBhdGlibGUgd2l0aCBwcm9ncmFtcyB0aGF0IGRlcGVuZCBvbiBiZWluZyBhYmxlCgkgIHRvIGNvbXB1dGUgdGhlIGV4YWN0IHNpemVzIG9mIGFueSBzdWNoIGRlY29yYXRpb25zLCBvcgoJICB0aGF0IHdhbnQgdG8gZHJhdyB0aGVpciBvd24uCgkgIFVubWFuYWdlZCBtb2RlIGlzIG9ubHkgdXNlZCBpZiBib3RoIE1hbmFnZWQgYW5kIERlc2t0b3AKCSAgYXJlIHNldCB0byBkaXNhYmxlZC4KCTwvcGFyYT4KICAgICAgPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogICAgPHZhcmxpc3RlbnRyeT4KICAgICAgPHRlcm0+RGVza3RvcC1pbi1hLUJveDwvdGVybT4KICAgICAgPGxpc3RpdGVtPgoJPHBhcmE+CgkgIFNwZWNpZmllZCBieSB1c2luZyB0aGUgPGxpdGVyYWw+RGVza3RvcDwvbGl0ZXJhbD4KCXdpbmUgY29uZmlndXJhdGlvbiBmaWxlIG9wdGlvbiAoc2VlIGJlbG93KS4KCSAgKGFkZGluZyBhIGdlb21ldHJ5LCBlLmcuIDxsaXRlcmFsPjgwMHg2MDA8L2xpdGVyYWw+Cglmb3IgYSBzdWNoLXNpemVkIGRlc2t0b3AsIG9yCgkgIGV2ZW4gPGxpdGVyYWw+ODAweDYwMCswKzA8L2xpdGVyYWw+IHRvCgkgIGF1dG9tYXRpY2FsbHkgcG9zaXRpb24gdGhlIGRlc2t0b3AgYXQgdGhlIHVwcGVyLWxlZnQKCSAgY29ybmVyIG9mIHRoZSBkaXNwbGF5KS4gVGhpcyBpcyB0aGUgbW9kZSBtb3N0CgkgIGNvbXBhdGlibGUgd2l0aCB0aGUgV2luZG93cyBtb2RlbC4gQWxsIHByb2dyYW0KCSAgd2luZG93cyB3aWxsIGp1c3QgYmUgV2luZS1kcmF3biB3aW5kb3dzIGluc2lkZSB0aGUKCSAgV2luZS1wcm92aWRlZCBkZXNrdG9wIHdpbmRvdyAod2hpY2ggd2lsbCBpdHNlbGYgYmUKCSAgbWFuYWdlZCBieSB5b3VyIHdpbmRvdyBtYW5hZ2VyKSwgYW5kIFdpbmRvd3MKCSAgcHJvZ3JhbXMgY2FuIHJvYW0gZnJlZWx5IHdpdGhpbiB0aGlzIHZpcnR1YWwKCSAgd29ya3NwYWNlIGFuZCB0aGluayB0aGV5IG93biBpdCBhbGwsIHdpdGhvdXQKCSAgZGlzdHVyYmluZyB5b3VyIG90aGVyIFggYXBwcy4KCU5vdGU6IGN1cnJlbnRseSB0aGVyZSdzIG9uZSBkZXNrdG9wIHdpbmRvdyBmb3IgZXZlcnkKCXByb2dyYW07IHRoaXMgd2lsbCBiZSBmaXhlZCBhdCBzb21lIHRpbWUuCgk8L3BhcmE+CiAgICAgIDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICA8L3ZhcmlhYmxlbGlzdD4KPC9zZWN0Mz4KCjxzZWN0Mz4KICA8dGl0bGU+VGhlIFt4MTFkcnZdIHNlY3Rpb248L3RpdGxlPgoKICA8dmFyaWFibGVsaXN0PgogICAgPHZhcmxpc3RlbnRyeT4KICAgICAgPHRlcm0+TWFuYWdlZDwvdGVybT4KICAgICAgPGxpc3RpdGVtPgoJPHBhcmE+CgkgIFdpbmUgY2FuIGxldCBmcmFtZSB3aW5kb3dzIGJlIG1hbmFnZWQgYnkgeW91ciB3aW5kb3cKCSAgbWFuYWdlci4gVGhpcyBvcHRpb24gc3BlY2lmaWVzIHdoZXRoZXIgeW91IHdhbnQgdGhhdAoJICBieSBkZWZhdWx0LgoJPC9wYXJhPgogICAgICA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT5EZXNrdG9wPC90ZXJtPgogICAgICA8bGlzdGl0ZW0+Cgk8cGFyYT4KCSAgQ3JlYXRlcyBhIG1haW4gZGVza3RvcCB3aW5kb3cgb2YgYSBzcGVjaWZpZWQgc2l6ZQoJdG8gZGlzcGxheSBhbGwgV2luZG93cyBwcm9ncmFtcyBpbi4KCVRoZSBzaXplIGFyZ3VtZW50IGNvdWxkIGUuZy4gYmUgIjgwMHg2MDAiLgoJPC9wYXJhPgogICAgICA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT5EWEdyYWI8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4KCTxwYXJhPgoJICBJZiB5b3UgZG9uJ3QgdXNlIERHQSwgeW91IG1heSB3YW50IGFuIGFsdGVybmF0aXZlCgkgIG1lYW5zIHRvIGNvbnZpbmNlIHRoZSBtb3VzZSBjdXJzb3IgdG8gc3RheSB3aXRoaW4gdGhlCgkgIGdhbWUgd2luZG93LiBUaGlzIG9wdGlvbiBkb2VzIHRoYXQuIE9mIGNvdXJzZSwgYXMgd2l0aAoJICBER0EsIGlmIFdpbmUgY3Jhc2hlcywgeW91J3JlIGluIHRyb3VibGUgKGFsdGhvdWdoIG5vdAoJICBhcyBiYWRseSBhcyBpbiB0aGUgREdBIGNhc2UsIHNpbmNlIHlvdSBjYW4gc3RpbGwgdXNlCgkgIHRoZSBrZXlib2FyZCB0byBnZXQgb3V0IG9mIFgpLgoJPC9wYXJhPgogICAgICA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT5Vc2VER0E8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4KCTxwYXJhPgoJICBUaGlzIHNwZWNpZmllcyB3aGV0aGVyIHlvdSB3YW50IERpcmVjdERyYXcgdG8gdXNlCgkgIFhGcmVlODYncyA8Zmlyc3R0ZXJtPkRpcmVjdCBHcmFwaGljcwoJICAgIEFyY2hpdGVjdHVyZTwvZmlyc3R0ZXJtPiAoREdBKSwgd2hpY2ggaXMgYWJsZSB0bwoJICB0YWtlIG92ZXIgdGhlIGVudGlyZSBkaXNwbGF5IGFuZCBydW4gdGhlIGdhbWUKCSAgZnVsbC1zY3JlZW4gYXQgbWF4aW11bSBzcGVlZC4gKFdpdGggREdBMSAoWEZyZWU4NgoJICAzLngpLCB5b3Ugc3RpbGwgaGF2ZSB0byBjb25maWd1cmUgdGhlIFggc2VydmVyIHRvIHRoZQoJICBnYW1lJ3MgcmVxdWVzdGVkIGJwcCBmaXJzdCwgYnV0IHdpdGggREdBMiAoWEZyZWU4NgoJICA0LngpLCBydW50aW1lIGRlcHRoLXN3aXRjaGluZyBtYXkgYmUgcG9zc2libGUsCgkgIGRlcGVuZGluZyBvbiB5b3VyIGRyaXZlcidzIGNhcGFiaWxpdGllcy4pIEJ1dCBiZSBhd2FyZQoJICB0aGF0IGlmIFdpbmUgY3Jhc2hlcyB3aGlsZSBpbiBER0EgbW9kZSwgaXQgbWF5IG5vdCBiZQoJICBwb3NzaWJsZSB0byByZWdhaW4gY29udHJvbCBvdmVyIHlvdXIgY29tcHV0ZXIgd2l0aG91dAoJICByZWJvb3RpbmcuIERHQSBub3JtYWxseSByZXF1aXJlcyBlaXRoZXIgcm9vdAoJICBwcml2aWxlZ2VzIG9yIHJlYWQvd3JpdGUgYWNjZXNzIHRvCgkgIDxmaWxlbmFtZT4vZGV2L21lbTwvZmlsZW5hbWU+LgoJPC9wYXJhPgogICAgICA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT5Vc2VYU2htPC90ZXJtPgogICAgICA8bGlzdGl0ZW0+Cgk8cGFyYT4KCSAgSWYgeW91IGRvbid0IHdhbnQgRGlyZWN0WCB0byB1c2UgREdBLCB5b3UgY2FuIGF0IGxlYXN0CgkgIHVzZSBYIFNoYXJlZCBNZW1vcnkgZXh0ZW5zaW9ucyAoWFNobSkuIEl0IGlzIG11Y2gKCSAgc2xvd2VyIHRoYW4gREdBLCBzaW5jZSB0aGUgYXBwIGRvZXNuJ3QgaGF2ZSBkaXJlY3QKCSAgYWNjZXNzIHRvIHRoZSBwaHlzaWNhbCBmcmFtZSBidWZmZXIsIGJ1dCB1c2luZyBzaGFyZWQKCSAgbWVtb3J5IHRvIGRyYXcgdGhlIGZyYW1lIGlzIGF0IGxlYXN0IGZhc3RlciB0aGFuCgkgIHNlbmRpbmcgdGhlIGRhdGEgdGhyb3VnaCB0aGUgc3RhbmRhcmQgWDExIHNvY2tldCwgZXZlbgoJICB0aG91Z2ggV2luZSdzIFhTaG0gc3VwcG9ydCBpcyBzdGlsbCBrbm93biB0byBjcmFzaAoJICBzb21ldGltZXMuCgk8L3BhcmE+CiAgICAgIDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPkRlc2t0b3BEb3VibGVCdWZmZXJlZDwvdGVybT4KICAgICAgPGxpc3RpdGVtPgoJPHBhcmE+CgkgIEFwcGxpZXMgb25seSBpZiB5b3UgdXNlIHRoZQoJICA8cGFyYW1ldGVyPi0tZGVza3RvcDwvcGFyYW1ldGVyPiBjb21tYW5kLWxpbmUgb3B0aW9uCgkgIHRvIHJ1biBpbiBhIGRlc2t0b3Agd2luZG93LiBTcGVjaWZpZXMgd2hldGhlciB0bwoJICBjcmVhdGUgdGhlIGRlc2t0b3Agd2luZG93IHdpdGggYSBkb3VibGUtYnVmZmVyZWQKCSAgdmlzdWFsLCBzb21ldGhpbmcgbW9zdCBPcGVuR0wgZ2FtZXMgbmVlZCB0byBydW4KCSAgY29ycmVjdGx5LgoJPC9wYXJhPgogICAgICA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT5BbGxvY1N5c3RlbUNvbG9yczwvdGVybT4KICAgICAgPGxpc3RpdGVtPgoJPHBhcmE+CgkgIEFwcGxpZXMgb25seSBpZiB5b3UgaGF2ZSBhIHBhbGV0dGUtYmFzZWQgZGlzcGxheSwgaS5lLgoJICBpZiB5b3VyIFggc2VydmVyIGlzIHNldCB0byBhIGRlcHRoIG9mIDhicHAsIGFuZCBpZiB5b3UKCSAgaGF2ZW4ndCByZXF1ZXN0ZWQgYSBwcml2YXRlIGNvbG9yIG1hcC4gSXQgc3BlY2lmaWVzCgkgIHRoZSBtYXhpbXVtIG51bWJlciBvZiBzaGFyZWQgY29sb3JtYXAgY2VsbHMgKHBhbGV0dGUKCSAgZW50cmllcykgV2luZSBzaG91bGQgb2NjdXB5LiBUaGUgaGlnaGVyIHRoaXMgdmFsdWUsCgkgIHRoZSBsZXNzIGNvbG9ycyB3aWxsIGJlIGF2YWlsYWJsZSB0byBvdGhlcgoJICBwcm9ncmFtcy4KCTwvcGFyYT4KICAgICAgPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogICAgPHZhcmxpc3RlbnRyeT4KICAgICAgPHRlcm0+UHJpdmF0ZUNvbG9yTWFwPC90ZXJtPgogICAgICA8bGlzdGl0ZW0+Cgk8cGFyYT4KCSAgQXBwbGllcyBvbmx5IGlmIHlvdSBoYXZlIGEgcGFsZXR0ZS1iYXNlZCBkaXNwbGF5LCBpLmUuCgkgIGlmIHlvdXIgWCBzZXJ2ZXIgaXMgc2V0IHRvIGEgZGVwdGggb2YgOGJwcC4gSXQKCSAgc3BlY2lmaWVzIHRoYXQgeW91IGRvbid0IHdhbnQgdG8gdXNlIHRoZSBzaGFyZWQgY29sb3IKCSAgbWFwLCBidXQgYSBwcml2YXRlIGNvbG9yIG1hcCwgd2hlcmUgYWxsIDI1NiBjb2xvcnMgYXJlCgkgIGF2YWlsYWJsZS4gVGhlIGRpc2FkdmFudGFnZSBpcyB0aGF0IFdpbmUncyBwcml2YXRlCgkgIGNvbG9yIG1hcCBpcyBvbmx5IHNlZW4gd2hpbGUgdGhlIG1vdXNlIHBvaW50ZXIgaXMKCSAgaW5zaWRlIGEgV2luZSB3aW5kb3csIHNvIHBzeWNoZWRlbGljIGZsYXNoaW5nIGFuZAoJICBmdW5reSBjb2xvcnMgd2lsbCBiZWNvbWUgcm91dGluZSBpZiB5b3UgdXNlIHRoZSBtb3VzZQoJICBhIGxvdC4KCTwvcGFyYT4KICAgICAgPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogICAgPHZhcmxpc3RlbnRyeT4KICAgICAgPHRlcm0+U3luY2hyb25vdXM8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4KCTxwYXJhPgoJICBUbyBiZSB1c2VkIGZvciBkZWJ1Z2dpbmcgWDExIG9wZXJhdGlvbnMuCglJZiBXaW5lIGNyYXNoZXMgd2l0aCBhbiBYMTEgZXJyb3IsIHRoZW4geW91IHNob3VsZCBlbmFibGUKCVN5bmNocm9ub3VzIG1vZGUgdG8gZGlzYWJsZSBYMTEgcmVxdWVzdCBjYWNoaW5nIGluIG9yZGVyCgl0byBtYWtlIHN1cmUgdGhhdCB0aGUgWDExIGVycm9yIGhhcHBlbnMgZGlyZWN0bHkgYWZ0ZXIKCXRoZSBjb3JyZXNwb25kaW5nIFgxMSBjYWxsIGluIHRoZSBsb2cgZmlsZSBhcHBlYXJzLgoJV2lsbCBzbG93IGRvd24gWDExIG91dHB1dCEKCTwvcGFyYT4KICAgICAgPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogICAgPHZhcmxpc3RlbnRyeT4KICAgICAgPHRlcm0+U2NyZWVuRGVwdGg8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4KCTxwYXJhPgoJICBBcHBsaWVzIG9ubHkgdG8gbXVsdGktZGVwdGggZGlzcGxheXMuIEl0IHNwZWNpZmllcwoJICB3aGljaCBvZiB0aGUgYXZhaWxhYmxlIGRlcHRocyBXaW5lIHNob3VsZCB1c2UgKGFuZAoJICB0ZWxsIFdpbmRvd3MgYXBwcyBhYm91dCkuCgk8L3BhcmE+CiAgICAgIDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPkRpc3BsYXk8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4KCTxwYXJhPgoJICBUaGlzIHNwZWNpZmllcyB3aGljaCBYMTEgZGlzcGxheSB0byB1c2UsIGFuZCBpZgoJICBzcGVjaWZpZWQsIHdpbGwgb3ZlcnJpZGUgdGhlCgkgIDxlbnZhcj5ESVNQTEFZPC9lbnZhcj4gZW52aXJvbm1lbnQgdmFyaWFibGUuCgk8L3BhcmE+CiAgICAgIDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxpc3RlbnRyeT4KICAgIDx2YXJsaXN0ZW50cnk+CiAgICAgIDx0ZXJtPlBlcmZlY3RHcmFwaGljczwvdGVybT4KICAgICAgPGxpc3RpdGVtPgoJPHBhcmE+CgkgIFRoaXMgb3B0aW9uIG9ubHkgZGV0ZXJtaW5lcyB3aGV0aGVyIGZhc3QgWDExIHJvdXRpbmVzCgkgIG9yIGV4YWN0IFdpbmUgcm91dGluZXMgd2lsbCBiZSB1c2VkIGZvciBjZXJ0YWluIFJPUAoJICBjb2RlcyBpbiBibGl0IG9wZXJhdGlvbnMuIE1vc3QgdXNlcnMgd29uJ3Qgbm90aWNlIGFueQoJICBkaWZmZXJlbmNlLgoJPC9wYXJhPgogICAgICA8L2xpc3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAgICA8dmFybGlzdGVudHJ5PgogICAgICA8dGVybT5UZXh0Q1A8L3Rlcm0+CiAgICAgIDxsaXN0aXRlbT4KCTxwYXJhPgoJQ29kZXBhZ2UgdG8gYmUgdXNlZCBmb3IgcmVuZGVyaW5nIHRoZSB0ZXh0IGluIFgxMQoJb3V0cHV0LiBTb21lIHNhbXBsZSB2YWx1ZXMgd291bGQgYmUgNDM3IChVU0EsIENhbmFkYSksCgk4NTAgKEV1cm9wZSksIDg1MiAoQ2VudHJhbC9FYXN0ZXJuIEV1cm9wZSksIDg1NQoJKEN5cmlsbGljKS4gRm9yIGFkZGl0aW9uYWwgc3VpdGFibGUgdmFsdWVzLCBzZWUgZS5nLiB0aGUgTGludXgKCWtlcm5lbCdzIGNvZGVwYWdlIGNvbmZpZ3VyYXRpb24gcGFnZS4KCTwvcGFyYT4KICAgICAgPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogIDwvdmFyaWFibGVsaXN0Pgo8L3NlY3QzPgo8L3NlY3QyPgoKPHNlY3QyPgo8dGl0bGU+Q29uZmlndXJpbmcgdGhlIHR0eWRydiBncmFwaGljcyBkcml2ZXI8L3RpdGxlPgo8cGFyYT4KICBDdXJyZW50bHksIHRoZSB0dHlkcnYgZG9lc24ndCBoYXZlIGFueSBzcGVjaWFsIGNvbmZpZ3VyYXRpb24KICBvcHRpb25zIHRvIHNldCBpbiB0aGUgY29uZmlndXJhdGlvbiBmaWxlLgo8L3BhcmE+Cjwvc2VjdDI+Cgo8L3NlY3QxPgoKPHNlY3QxIGlkPSJjb25maWctd2luZG93cy12ZXJzaW9ucyI+Cgo8dGl0bGU+U2V0dGluZyB0aGUgV2luZG93cyBhbmQgRE9TIHZlcnNpb24gdmFsdWU8L3RpdGxlPgoKPHBhcmE+CldyaXR0ZW4gYnkgJm5hbWUtYW5kcmVhcy1tb2hyOyA8ZW1haWw+JmVtYWlsLWFuZHJlYXMtbW9ocjs8L2VtYWlsPgpPY3QgMTggMjAwMgo8L3BhcmE+Cgo8cGFyYT4KVGhlIHdpbmRvd3MgYW5kIERPUyB2ZXJzaW9uIHZhbHVlIGEgcHJvZ3JhbSBnZXRzIGUuZy4gYnkgY2FsbGluZyB0aGUKV2luZG93cyBmdW5jdGlvbiBHZXRWZXJzaW9uKCkgcGxheXMgYSB2ZXJ5IGltcG9ydGFudCByb2xlOgpJZiB5b3VyIFdpbmUgaW5zdGFsbGF0aW9uIGZvciB3aGF0ZXZlciByZWFzb24gZmFpbHMgdG8gcHJvdmlkZQp0byB5b3VyIHByb2dyYW0gdGhlIGNvcnJlY3QgdmVyc2lvbiB2YWx1ZSB0aGF0IGl0IGV4cGVjdHMsCnRoZW4gdGhlIHByb2dyYW0gbWlnaHQgYXNzdW1lIHNvbWUgdmVyeSBiYWQgdGhpbmdzIGFuZCBmYWlsIChpbgp0aGUgd29yc3QgY2FzZSBldmVuIHNpbGVudGx5ISkuCgpGb3J0dW5hdGVseSBXaW5lIGNvbnRhaW5zIHNvbWUgbW9yZSBvciBsZXNzIGludGVsbGlnZW50IFdpbmRvd3MKdmVyc2lvbiBndWVzc2luZyBhbGdvcml0aG0gdGhhdCB3aWxsIHRyeSB0byBndWVzcyB0aGUgV2luZG93cwp2ZXJzaW9uIGEgcHJvZ3JhbSBtaWdodCBleHBlY3QgYW5kIHBhc3MgdGhhdCBvbmUgb24gdG8gdGhlCnByb2dyYW0uCgpUaHVzIHlvdSBzaG91bGQgPGVtcGhhc2lzPm5vdDwvZW1waGFzaXM+IGxpZ2h0bHkgY29uZmlndXJlIGEgdmVyc2lvbiB2YWx1ZSwgYXMgdGhpcyB3aWxsIGJlIGEgImZvcmNlZCIgdmFsdWUgYW5kIHRodXMgdHVybiBvdXQgdG8gYmUgcmF0aGVyIGhhcm1mdWwgdG8gcHJvcGVyIG9wZXJhdGlvbi4gSW4gb3RoZXIgd29yZHM6IG9ubHkgZXhwbGljaXRseSBzZXQgYSBXaW5kb3dzIHZlcnNpb24gdmFsdWUgaW4gY2FzZSBXaW5lJ3Mgb3duIHZlcnNpb24gZGV0ZWN0aW9uIHdhcyB1bmFibGUgdG8gcHJvdmlkZSB0aGUgY29ycmVjdCBXaW5kb3dzIHZlcnNpb24gYW5kIHRoZSBwcm9ncmFtIGZhaWxzLgo8L3BhcmE+Cgo8c2VjdDI+Cjx0aXRsZT5Ib3cgdG8gY29uZmlndXJlIHRoZSBXaW5kb3dzIGFuZCBET1MgdmVyc2lvbiB2YWx1ZSBXaW5lCnNob3VsZCByZXR1cm48L3RpdGxlPgoKPHBhcmE+ClRoZSB2ZXJzaW9uIHZhbHVlcyBjYW4gYmUgY29uZmlndXJlZCBpbiB0aGUgd2luZSBjb25maWd1cmF0aW9uIGZpbGUgaW4KdGhlIFtWZXJzaW9uXSBzZWN0aW9uLgo8L3BhcmE+Cgo8dmFyaWFibGVsaXN0PgogIDx2YXJsaXN0ZW50cnk+CiAgICA8dGVybT4iV2luZG93cyIgPSAiJmx0O3ZlcnNpb24gc3RyaW5nJmd0OyI8L3Rlcm0+CiAgICA8bGlzdGl0ZW0+CiAgICAgIDxwYXJhPgoJZGVmYXVsdDogbm9uZTsgY2hvc2VuIGJ5IHNlbWktaW50ZWxsaWdlbnQgZGV0ZWN0aW9uCgltZWNoYW5pc20gYmFzZWQgb24gRExMIGVudmlyb25tZW50LgoJVXNlZCB0byBzcGVjaWZ5IHdoaWNoIFdpbmRvd3MgdmVyc2lvbiB0byByZXR1cm4gdG8KCXByb2dyYW1zICAoZm9yY2VkICB2YWx1ZSwgb3ZlcnJpZGVzIHN0YW5kYXJkIGRldGVjdGlvbgoJbWVjaGFuaXNtISkuIFZhbGlkICBzZXR0aW5ncyBhcmUgZS5nLiAid2luMzEiLCAid2luOTUiLAoJIndpbjk4IiwgICJ3aW4yayIsICAid2lueHAiLgoJQWxzbyB2YWxpZCBhcyBhbgoJPGxpbmsgbGlua2VuZD0iY29uZmlnLWFwcGRlZmF1bHRzIj5BcHBEZWZhdWx0czwvbGluaz4KCXNldHRpbmcgKHJlY29tbWVuZGVkL3ByZWZlcnJlZCB1c2UpLgogICAgICA8L3BhcmE+CiAgICA8L2xpc3RpdGVtPgogIDwvdmFybGlzdGVudHJ5PgogIDx2YXJsaXN0ZW50cnk+CiAgICA8dGVybT4iRE9TIj0iJmx0O3ZlcnNpb24gc3RyaW5nJmd0OyI8L3Rlcm0+CiAgICA8bGlzdGl0ZW0+CiAgICAgIDxwYXJhPgoJVXNlZCB0byBzcGVjaWZ5IHRoZSBET1MgdmVyc2lvbiB0aGF0IHNob3VsZCBiZSByZXR1cm5lZAoJdG8gcHJvZ3JhbXMuIE9ubHkgdGFrZXMgZWZmZWN0IGluIGNhc2UgV2luZSBhY3RzIGFzCgkid2luMzEiIFdpbmRvd3MgdmVyc2lvbiEgQ29tbW9uIERPUyB2ZXJzaW9uIHNldHRpbmdzCglpbmNsdWRlIDYuMjIsIDYuMjAsIDYuMDAsIDUuMDAsIDQuMDAsIDMuMzAsIDMuMTAuCglBbHNvIHZhbGlkIGFzIGFuCgk8bGluayBsaW5rZW5kPSJjb25maWctYXBwZGVmYXVsdHMiPkFwcERlZmF1bHRzPC9saW5rPgoJc2V0dGluZyAocmVjb21tZW5kZWQvcHJlZmVycmVkIHVzZSkuCiAgICAgIDwvcGFyYT4KICAgIDwvbGlzdGl0ZW0+CiAgPC92YXJsaXN0ZW50cnk+CjwvdmFyaWFibGVsaXN0Pgo8L3NlY3QyPgo8L3NlY3QxPgoKJmZvbnRzOwomcHJpbnRpbmc7Cgo8c2VjdDEgaWQ9ImNvbmZpZy13aW45NWxvb2siPgo8dGl0bGU+V2luOTUvOTggTG9vayBBbmQgRmVlbDwvdGl0bGU+CjxwYXJhPgpXcml0dGVuIGJ5ICZuYW1lLWRhdmlkLWN1dGhiZXJ0OyA8ZW1haWw+JmVtYWlsLWRhdmlkLWN1dGhiZXJ0OzwvZW1haWw+CjwvcGFyYT4KPHBhcmE+CihFeHRyYWN0ZWQgZnJvbSA8ZmlsZW5hbWU+d2luZS9kb2N1bWVudGF0aW9uL3dpbjk1bG9vazwvZmlsZW5hbWU+KQo8L3BhcmE+CjxwYXJhPgpXaW45NS9XaW45OCBpbnRlcmZhY2UgY29kZSBpcyBiZWluZyBpbnRyb2R1Y2VkLgo8L3BhcmE+CjxwYXJhPgpJbnN0ZWFkIG9mIGNvbXBpbGluZyBXaW5lIGZvciBXaW4zLjEgdnMuIFdpbjk1IHVzaW5nCjxjb25zdGFudD4jZGVmaW5lPC9jb25zdGFudD4gc3dpdGNoZXMsIHRoZSBjb2RlIG5vdyBsb29rcyBpbiBhCnNwZWNpYWwgW1R3ZWFrLkxheW91dF0gc2VjdGlvbiBvZgo8ZmlsZW5hbWU+fi8ud2luZS9jb25maWc8L2ZpbGVuYW1lPiBmb3IgYQo8bGl0ZXJhbD4iV2luZUxvb2siID0gIldpbjk1IjwvbGl0ZXJhbD4gb3IKPGxpdGVyYWw+IldpbmVMb29rIiA9ICJXaW45OCI8L2xpdGVyYWw+IGVudHJ5Lgo8L3BhcmE+CjxwYXJhPgpBIGZldyBuZXcgc2VjdGlvbnMgYW5kIGEgbnVtYmVyIG9mIGVudHJpZXMgaGF2ZSBiZWVuIGFkZGVkIHRvCnRoZSA8ZmlsZW5hbWU+fi8ud2luZS9jb25maWc8L2ZpbGVuYW1lPiBmaWxlIC0tIHRoZXNlIGFyZSBmb3IKZGVidWdnaW5nIHRoZSBXaW45NSB0d2Vha3Mgb25seSBhbmQgbWF5IGJlIHJlbW92ZWQgaW4gYSBmdXR1cmUKcmVsZWFzZSEgIFRoZXNlIGVudHJpZXMvc2VjdGlvbnMgYXJlOgo8L3BhcmE+Cjxwcm9ncmFtbGlzdGluZz4KW1R3ZWFrLkZvbnRzXQoiU3lzdGVtLkhlaWdodCIgPSAiJmx0O3BvaW50IHNpemU+IiAgICAjIFNldHMgdGhlIGhlaWdodCBvZiB0aGUgc3lzdGVtIHR5cGVmYWNlCiJTeXN0ZW0uQm9sZCIgPSAiW3RydWV8ZmFsc2VdIiAgICAgICMgV2hldGhlciB0aGUgc3lzdGVtIGZvbnQgc2hvdWxkIGJlIGJvbGRmYWNlZAoiU3lzdGVtLkl0YWxpYyIgPSAiW3RydWV8ZmFsc2VdIiAgICAjIFdoZXRoZXIgdGhlIHN5c3RlbSBmb250IHNob3VsZCBiZSBpdGFsaWNpemVkCiJTeXN0ZW0uVW5kZXJsaW5lIiA9ICJbdHJ1ZXxmYWxzZV0iICMgV2hldGhlciB0aGUgc3lzdGVtIGZvbnQgc2hvdWxkIGJlIHVuZGVybGluZWQKIlN5c3RlbS5TdHJpa2VPdXQiID0gIlt0cnVlfGZhbHNlXSIgIyBXaGV0aGVyIHRoZSBzeXN0ZW0gZm9udCBzaG91bGQgYmUgc3RydWNrIG91dAoiT0VNRml4ZWQueHh4IiAgICAgICAgICAgICAgICAgICMgU2FtZSBwYXJhbWV0ZXJzIGZvciB0aGUgT0VNIGZpeGVkIHR5cGVmYWNlCiJBbnNpRml4ZWQueHh4IiAgICAgICAgICAgICAgICAgIyBTYW1lIHBhcmFtZXRlcnMgZm9yIHRoZSBBbnNpIGZpeGVkIHR5cGVmYWNlCiJBbnNpVmFyLnh4eCIgICAgICAgICAgICAgICAgICAgIyBTYW1lIHBhcmFtZXRlcnMgZm9yIHRoZSBBbnNpIHZhcmlhYmxlIHR5cGVmYWNlCiJTeXN0ZW1GaXhlZC54eHgiICAgICAgICAgICAgICAgIyBTYW1lIHBhcmFtZXRlcnMgZm9yIHRoZSBTeXN0ZW0gZml4ZWQgdHlwZWZhY2UKCltUd2Vhay5MYXlvdXRdCiJXaW5lTG9vayIgPSAiW1dpbjMxfFdpbjk1fFdpbjk4XSIgICMgQ2hhbmdlcyBXaW5lJ3MgbG9vayBhbmQgZmVlbAo8L3Byb2dyYW1saXN0aW5nPgo8L3NlY3QxPgoKPHNlY3QxIGlkPSJjb25maWcta2V5Ym9hcmQiPgo8dGl0bGU+S2V5Ym9hcmQ8L3RpdGxlPgoKPHBhcmE+CldyaXR0ZW4gYnkgJm5hbWUtb3ZlLWthYXZlbjsgPGVtYWlsPiZlbWFpbC1vdmUta2FhdmVuOzwvZW1haWw+CjwvcGFyYT4KPHBhcmE+CihFeHRyYWN0ZWQgZnJvbSA8ZmlsZW5hbWU+d2luZS9kb2N1bWVudGF0aW9uL2tleWJvYXJkPC9maWxlbmFtZT4pCjwvcGFyYT4KCjxwYXJhPgpXaW5lIG5vdyBuZWVkcyB0byBrbm93IGFib3V0IHlvdXIga2V5Ym9hcmQgbGF5b3V0LiBUaGlzCnJlcXVpcmVtZW50IGNvbWVzIGZyb20gYSBuZWVkIGZyb20gbWFueSBhcHBzIHRvIGhhdmUgdGhlCmNvcnJlY3Qgc2NhbmNvZGVzIGF2YWlsYWJsZSwgc2luY2UgdGhleSByZWFkIHRoZXNlIGRpcmVjdGx5LAppbnN0ZWFkIG9mIGp1c3QgdGFraW5nIHRoZSBjaGFyYWN0ZXJzIHJldHVybmVkIGJ5IHRoZSBYCnNlcnZlci4gVGhpcyBtZWFucyB0aGF0IFdpbmUgbm93IG5lZWRzIHRvIGhhdmUgYSBtYXBwaW5nIGZyb20KWCBrZXlzIHRvIHRoZSBzY2FuY29kZXMgdGhlc2UgcHJvZ3JhbXMgZXhwZWN0Lgo8L3BhcmE+CjxwYXJhPgpPbiBzdGFydHVwLCBXaW5lIHdpbGwgdHJ5IHRvIHJlY29nbml6ZSB0aGUgYWN0aXZlIFggbGF5b3V0IGJ5CnNlZWluZyBpZiBpdCBtYXRjaGVzIGFueSBvZiB0aGUgZGVmaW5lZCB0YWJsZXMuIElmIGl0IGRvZXMsCmV2ZXJ5dGhpbmcgaXMgYWxyaWdodC4gSWYgbm90LCB5b3UgbmVlZCB0byBkZWZpbmUgaXQuCjwvcGFyYT4KPHBhcmE+ClRvIGRvIHRoaXMsIG9wZW4gdGhlIGZpbGUKPGZpbGVuYW1lPmRsbHMveDExZHJ2L2tleWJvYXJkLmM8L2ZpbGVuYW1lPiBhbmQgdGFrZSBhIGxvb2sKYXQgdGhlIGV4aXN0aW5nIHRhYmxlcy4gTWFrZSBhIGJhY2t1cCBjb3B5IG9mIGl0LCBlc3BlY2lhbGx5CmlmIHlvdSBkb24ndCB1c2UgQ1ZTLgo8L3BhcmE+CjxwYXJhPgpXaGF0IHlvdSByZWFsbHkgd291bGQgbmVlZCB0byBkbywgaXMgZmluZCBvdXQgd2hpY2ggc2NhbmNvZGUKZWFjaCBrZXkgbmVlZHMgdG8gZ2VuZXJhdGUuICBGaW5kIGl0IGluIHRoZQo8ZnVuY3Rpb24+bWFpbl9rZXlfc2NhbjwvZnVuY3Rpb24+IHRhYmxlLCB3aGljaCBsb29rcyBsaWtlCnRoaXM6CjwvcGFyYT4KPHByb2dyYW1saXN0aW5nPgpzdGF0aWMgY29uc3QgaW50IG1haW5fa2V5X3NjYW5bTUFJTl9MRU5dID0KewovKiB0aGlzIGlzIG15ICgxMDIta2V5KSBrZXlib2FyZCBsYXlvdXQsIHNvcnJ5IGlmIGl0IGRvZXNuJ3QgcXVpdGUgbWF0Y2ggeW91cnMgKi8KMHgyOSwweDAyLDB4MDMsMHgwNCwweDA1LDB4MDYsMHgwNywweDA4LDB4MDksMHgwQSwweDBCLDB4MEMsMHgwRCwKMHgxMCwweDExLDB4MTIsMHgxMywweDE0LDB4MTUsMHgxNiwweDE3LDB4MTgsMHgxOSwweDFBLDB4MUIsCjB4MUUsMHgxRiwweDIwLDB4MjEsMHgyMiwweDIzLDB4MjQsMHgyNSwweDI2LDB4MjcsMHgyOCwweDJCLAoweDJDLDB4MkQsMHgyRSwweDJGLDB4MzAsMHgzMSwweDMyLDB4MzMsMHgzNCwweDM1LAoweDU2IC8qIHRoZSAxMDJuZCBrZXkgKGFjdHVhbGx5IHRvIHRoZSByaWdodCBvZiBsLXNoaWZ0KSAqLwp9Owo8L3Byb2dyYW1saXN0aW5nPgo8cGFyYT4KTmV4dCwgYXNzaWduIGVhY2ggc2NhbmNvZGUgdGhlIGNoYXJhY3RlcnMgaW1wcmludGVkIG9uIHRoZQprZXljYXBzLiBUaGlzIHdhcyBkb25lIChzb3J0IG9mKSBmb3IgdGhlIFVTIDEwMS1rZXkga2V5Ym9hcmQsCndoaWNoIHlvdSBjYW4gZmluZCBuZWFyIHRoZSB0b3AgaW4KPGZpbGVuYW1lPmtleWJvYXJkLmM8L2ZpbGVuYW1lPi4gSXQgYWxzbyBzaG93cyB0aGF0IGlmIHRoZXJlCmlzIG5vIDEwMm5kIGtleSwgeW91IGNhbiBza2lwIHRoYXQuCjwvcGFyYT4KPHBhcmE+Ckhvd2V2ZXIsIGZvciBtb3N0IGludGVybmF0aW9uYWwgMTAyLWtleSBrZXlib2FyZHMsIHdlIGhhdmUKZG9uZSBpdCBlYXN5IGZvciB5b3UuIFRoZSBzY2FuY29kZSBsYXlvdXQgZm9yIHRoZXNlIGFscmVhZHkKcHJldHR5IG11Y2ggbWF0Y2hlcyB0aGUgcGh5c2ljYWwgbGF5b3V0IGluIHRoZQo8ZnVuY3Rpb24+bWFpbl9rZXlfc2NhbjwvZnVuY3Rpb24+LCBzbyBhbGwgeW91IG5lZWQgdG8gZG8gaXMKdG8gZ28gdGhyb3VnaCBhbGwgdGhlIGtleXMgdGhhdCBnZW5lcmF0ZSBjaGFyYWN0ZXJzIG9uIHlvdXIKbWFpbiBrZXlib2FyZCAoZXhjZXB0IHNwYWNlYmFyKSwgYW5kIHN0dWZmIHRob3NlIGludG8gYW4KYXBwcm9wcmlhdGUgdGFibGUuIFRoZSBvbmx5IGV4Y2VwdGlvbiBpcyB0aGF0IHRoZSAxMDJuZCBrZXksCndoaWNoIGlzIHVzdWFsbHkgdG8gdGhlIGxlZnQgb2YgdGhlIGZpcnN0IGtleSBvZiB0aGUgbGFzdCBsaW5lCih1c3VhbGx5IDxrZXljYXA+Wjwva2V5Y2FwPiksIG11c3QgYmUgcGxhY2VkIG9uIGEgc2VwYXJhdGUKbGluZSBhZnRlciB0aGUgbGFzdCBsaW5lLgo8L3BhcmE+CjxwYXJhPgpGb3IgZXhhbXBsZSwgbXkgTm9yd2VnaWFuIGtleWJvYXJkIGxvb2tzIGxpa2UgdGhpcwo8L3BhcmE+CjxzY3JlZW4+CqcgICEgICIgICMgIKQgICUgICYgIC8gICggICkgID0gID8gIGAgIEJhY2stCnwgIDEgIDJAIDOjIDQkIDUgIDYgIDd7IDhbIDldIDB9ICsgIFy0IHNwYWNlCgpUYWIgUSAgVyAgRSAgUiAgVCAgWSAgVSAgSSAgTyAgUCAgxSAgXgoJCQkgICAgIKh+CgkJCQlFbnRlcgpDYXBzIEEgIFMgIEQgIEYgIEcgIEggIEogIEsgIEwgINggIMYgICoKTG9jayAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnCgpTaC0gPiBaICBYICBDICBWICBCICBOICBNICA7ICA6ICBfICBTaGlmdAppZnQgJmx0OyAgICAgICAgICAgICAgICAgICAgICAsICAuICAtCgpDdHJsICBBbHQgICAgICAgU3BhY2ViYXIgICAgICAgQWx0R3IgIEN0cmwKPC9zY3JlZW4+CjxwYXJhPgpOb3RlIHRoZSAxMDJuZCBrZXksIHdoaWNoIGlzIHRoZSA8a2V5Y2FwPiZsdDs+PC9rZXljYXA+IGtleSwgdG8KdGhlIGxlZnQgb2YgPGtleWNhcD5aPC9rZXljYXA+LiBUaGUgY2hhcmFjdGVyIHRvIHRoZSByaWdodCBvZgp0aGUgbWFpbiBjaGFyYWN0ZXIgaXMgdGhlIGNoYXJhY3RlciBnZW5lcmF0ZWQgYnkKPGtleWNhcD5BbHRHcjwva2V5Y2FwPi4KPC9wYXJhPgo8cGFyYT4KVGhpcyBrZXlib2FyZCBpcyBkZWZpbmVkIGFzIGZvbGxvd3M6CjwvcGFyYT4KPHByb2dyYW1saXN0aW5nPgpzdGF0aWMgY29uc3QgY2hhciBtYWluX2tleV9OT1tNQUlOX0xFTl1bNF0gPQp7CiJ8pyIsIjEhIiwiMlwiQCIsIjMjoyIsIjSkJCIsIjUlIiwiNiYiLCI3L3siLCI4KFsiLCI5KV0iLCIwPX0iLCIrPyIsIlxctCIsCiJxUSIsIndXIiwiZUUiLCJyUiIsInRUIiwieVkiLCJ1VSIsImlJIiwib08iLCJwUCIsIuXFIiwiqF5+IiwKImFBIiwic1MiLCJkRCIsImZGIiwiZ0ciLCJoSCIsImpKIiwia0siLCJsTCIsIvjYIiwi5sYiLCInKiIsCiJ6WiIsInhYIiwiY0MiLCJ2ViIsImJCIiwibk4iLCJtTSIsIiw7IiwiLjoiLCItXyIsCiImbHQ7PiIKfTsKPC9wcm9ncmFtbGlzdGluZz4KPHBhcmE+CkV4Y2VwdCB0aGF0ICIgYW5kIFwgbmVlZHMgdG8gYmUgcXVvdGVkIHdpdGggYSBiYWNrc2xhc2gsIGFuZAp0aGF0IHRoZSAxMDJuZCBrZXkgaXMgb24gYSBzZXBhcmF0ZSBsaW5lLCBpdCdzIHByZXR0eQpzdHJhaWdodGZvcndhcmQuCjwvcGFyYT4KPHBhcmE+CkFmdGVyIHlvdSBoYXZlIHdyaXR0ZW4gc3VjaCBhIHRhYmxlLCB5b3UgbmVlZCB0byBhZGQgaXQgdG8gdGhlCjxmdW5jdGlvbj5tYWluX2tleV90YWJbXTwvZnVuY3Rpb24+IGxheW91dCBpbmRleCB0YWJsZS4gVGhpcwp3aWxsIGxvb2sgbGlrZSB0aGlzOgo8L3BhcmE+Cjxwcm9ncmFtbGlzdGluZz4Kc3RhdGljIHN0cnVjdCB7CldPUkQgbGFuZywgYW5zaV9jb2RlcGFnZSwgb2VtX2NvZGVwYWdlOwpjb25zdCBjaGFyICgqa2V5KVtNQUlOX0xFTl1bNF07Cn0gbWFpbl9rZXlfdGFiW109ewouLi4KLi4uCntNQUtFTEFOR0lEKExBTkdfTk9SV0VHSUFOLFNVQkxBTkdfREVGQVVMVCksICAxMjUyLCA4NjUsICZhbXA7bWFpbl9rZXlfTk99LAouLi4KPC9wcm9ncmFtbGlzdGluZz4KPHBhcmE+CkFmdGVyIHlvdSBoYXZlIGFkZGVkIHlvdXIgdGFibGUsIHJlY29tcGlsZSBXaW5lIGFuZCB0ZXN0IHRoYXQKaXQgd29ya3MuIElmIGl0IGZhaWxzIHRvIGRldGVjdCB5b3VyIHRhYmxlLCB0cnkgcnVubmluZwo8L3BhcmE+CjxzY3JlZW4+CndpbmUgLS1kZWJ1Z21zZyAra2V5LCtrZXlib2FyZCA+JiBrZXkubG9nCiAgICAgIDwvc2NyZWVuPgogICAgICA8cGFyYT4KICAgICAgICBhbmQgbG9vayBpbiB0aGUgcmVzdWx0aW5nIDxmaWxlbmFtZT5rZXkubG9nPC9maWxlbmFtZT4gZmlsZSB0bwogICAgICAgIGZpbmQgdGhlIGVycm9yIG1lc3NhZ2VzIGl0IGdpdmVzIGZvciB5b3VyIGxheW91dC4KICAgICAgPC9wYXJhPgogICAgICA8cGFyYT4KICAgICAgICBOb3RlIHRoYXQgdGhlIDxjb25zdGFudD5MQU5HXyo8L2NvbnN0YW50PiBhbmQKICAgICAgICA8Y29uc3RhbnQ+U1VCTEFOR18qPC9jb25zdGFudD4gZGVmaW5pdGlvbnMgYXJlIGluCiAgICAgICAgPGZpbGVuYW1lPmluY2x1ZGUvd2lubmxzLmg8L2ZpbGVuYW1lPiwgd2hpY2ggeW91IG1pZ2h0IG5lZWQgdG8KICAgICAgICBrbm93IHRvIGZpbmQgb3V0IHdoaWNoIG51bWJlcnMgeW91ciBsYW5ndWFnZSBpcyBhc3NpZ25lZCwgYW5kCiAgICAgICAgZmluZCBpdCBpbiB0aGUgZGVidWdtc2cgb3V0cHV0LiBUaGUgbnVtYmVycyB3aWxsIGJlCiAgICAgICAgPGxpdGVyYWw+KFNVQkxBTkcgKiAweDQwMCArIExBTkcpPC9saXRlcmFsPiwgc28sIGZvciBleGFtcGxlCiAgICAgICAgdGhlIGNvbWJpbmF0aW9uIDxsaXRlcmFsPkxBTkdfTk9SV0VHSUFOICgweDE0KTwvbGl0ZXJhbD4gYW5kCiAgICAgICAgPGxpdGVyYWw+U1VCTEFOR19ERUZBVUxUICgweDEpPC9saXRlcmFsPiB3aWxsIGJlIChpbiBoZXgpCiAgICAgICAgPGxpdGVyYWw+MTQgKyAxKjQwMCA9IDQxNDwvbGl0ZXJhbD4sIHNvIHNpbmNlIEknbSBOb3J3ZWdpYW4sIEkKICAgICAgICBjb3VsZCBsb29rIGZvciA8bGl0ZXJhbD4wNDE0PC9saXRlcmFsPiBpbiB0aGUgZGVidWdtc2cgb3V0cHV0CiAgICAgICAgdG8gZmluZCBvdXQgd2h5IG15IGtleWJvYXJkIHdvbid0IGRldGVjdC4KICAgICAgPC9wYXJhPgogICAgICA8cGFyYT4KICAgICAgICBPbmNlIGl0IHdvcmtzLCBzdWJtaXQgaXQgdG8gdGhlIFdpbmUgcHJvamVjdC4gSWYgeW91IHVzZSBDVlMsCiAgICAgICAgeW91IHdpbGwganVzdCBoYXZlIHRvIGRvCiAgICAgIDwvcGFyYT4KICAgICAgPHNjcmVlbj4KY3ZzIC16MyBkaWZmIC11IGRsbHMveDExZHJ2L2tleWJvYXJkLmMgPiBsYXlvdXQuZGlmZgogICAgICA8L3NjcmVlbj4KICAgICAgPHBhcmE+CiAgICAgICAgZnJvbSB5b3VyIG1haW4gV2luZSBkaXJlY3RvcnksIHRoZW4gc3VibWl0CiAgICAgICAgPGZpbGVuYW1lPmxheW91dC5kaWZmPC9maWxlbmFtZT4gdG8KICAgICAgICA8ZW1haWw+d2luZS1wYXRjaGVzQHdpbmVocS5jb208L2VtYWlsPiBhbG9uZyB3aXRoIGEgYnJpZWYgbm90ZQogICAgICAgIG9mIHdoYXQgaXQgaXMuCiAgICAgIDwvcGFyYT4KICAgICAgPHBhcmE+CiAgICAgICAgSWYgeW91IGRvbid0IHVzZSBDVlMsIHlvdSBuZWVkIHRvIGRvCiAgICAgIDwvcGFyYT4KICAgICAgPHNjcmVlbj4KZGlmZiAtdSB0aGVfYmFja3VwX2ZpbGVfeW91X21hZGUgZGxscy94MTFkcnYva2V5Ym9hcmQuYyA+IGxheW91dC5kaWZmCiAgICAgIDwvc2NyZWVuPgogICAgICA8cGFyYT4KICAgICAgICBhbmQgc3VibWl0IGl0IGFzIGV4cGxhaW5lZCBhYm92ZS4KICAgICAgPC9wYXJhPgogICAgICA8cGFyYT4KICAgICAgICBJZiB5b3UgZGlkIGl0IHJpZ2h0LCBpdCB3aWxsIGJlIGluY2x1ZGVkIGluIHRoZSBuZXh0IFdpbmUKICAgICAgICByZWxlYXNlLCBhbmQgYWxsIHRoZSB0cm91Ymxlc29tZSBwcm9ncmFtcyAoZXNwZWNpYWxseQogICAgICAgIHJlbW90ZS1jb250cm9sIHByb2dyYW1zKSBhbmQgZ2FtZXMgdGhhdCB1c2Ugc2NhbmNvZGVzIHdpbGwKICAgICAgICBiZSBoYXBwaWx5IHVzaW5nIHlvdXIga2V5Ym9hcmQgbGF5b3V0LCBhbmQgeW91IHdvbid0IGdldCB0aG9zZQogICAgICAgIGFubm95aW5nIGZpeG1lIG1lc3NhZ2VzIGVpdGhlci4KICAgICAgPC9wYXJhPgogICAgICA8cGFyYT4KICAgICAgICBHb29kIGx1Y2suCiAgICAgIDwvcGFyYT4KICAgIDwvc2VjdDE+CgogICAgPHNlY3QxIGlkPSJjb25maWctc2NzaS1zdXBwb3J0Ij4KICAgICAgPHRpdGxlPlNDU0kgU3VwcG9ydDwvdGl0bGU+CiAgICAgIDxwYXJhPgogICAgICAgIFdyaXR0ZW4gYnkgJm5hbWUtYnJ1Y2UtbWlsbmVyOyA8ZW1haWw+JmVtYWlsLWJydWNlLW1pbG5lcjs8L2VtYWlsPjsKICAgICAgICBBZGRpdGlvbnMgYnkgJm5hbWUtYW5kcmVhcy1tb2hyOyA8ZW1haWw+JmVtYWlsLWFuZHJlYXMtbW9ocjs8L2VtYWlsPgogICAgICA8L3BhcmE+CiAgICAgIDxwYXJhPgogICAgICAgIChFeHRyYWN0ZWQgZnJvbSA8ZmlsZW5hbWU+d2luZS9kb2N1bWVudGF0aW9uL2FzcGk8L2ZpbGVuYW1lPikKICAgICAgPC9wYXJhPgoKICAgICAgPHBhcmE+CiAgICAgICAgVGhpcyBmaWxlIGRlc2NyaWJlcyBzZXR0aW5nIHVwIHRoZSBXaW5kb3dzIEFTUEkgaW50ZXJmYWNlLgogICAgICA8L3BhcmE+CgogICAgICA8cGFyYT4KICAgICAgICA8d2FybmluZz48dGl0bGU+V2FybmluZy9XYXJuaW5nL1dhcm5pbmchISEhISE8L3RpdGxlPgogICAgICAgICAgPHBhcmE+VGhpcyBtYXkgdHJhc2ggeW91ciBzeXN0ZW0gaWYgdXNlZCBpbmNvcnJlY3RseS4gIEl0IG1heQoJCSAgZXZlbiB0cmFzaCB5b3VyIHN5c3RlbSB3aGVuIHVzZWQgPGVtcGhhc2lzPmNvcnJlY3RseTwvPiEKICAgICAgICAgIDwvcGFyYT4KICAgICAgICA8L3dhcm5pbmc+CiAgICAgIDwvcGFyYT4KCiAgICAgIDxwYXJhPgogICAgICAgIE5vdyB0aGF0IEkgaGF2ZSBzYWlkIHRoYXQuIEFTUEkgaXMgYSBkaXJlY3QgbGluayB0byBTQ1NJIGRldmljZXMgZnJvbQogICAgICAgIHdpbmRvd3MgcHJvZ3JhbXMuIEFTUEkganVzdCBmb3J3YXJkcyB0aGUgU0NTSSBjb21tYW5kcyB0aGF0IHByb2dyYW1zIHNlbmQKICAgICAgICB0byBpdCB0byB0aGUgU0NTSSBidXMuCiAgICAgIDwvcGFyYT4KICAgICAgPHBhcmE+CiAgICAgICAgSWYgeW91IHVzZSB0aGUgd3JvbmcgU0NTSSBkZXZpY2UgaW4geW91ciBzZXR1cCBmaWxlLCB5b3UgY2FuIHNlbmQKICAgICAgICBjb21wbGV0ZWx5IGJvZ3VzIGNvbW1hbmRzIHRvIHRoZSB3cm9uZyBkZXZpY2UgLSBBbiBleGFtcGxlIHdvdWxkIGJlCiAgICAgICAgZm9ybWF0dGluZyB5b3VyIGhhcmQgZHJpdmVzIChhc3N1bWluZyB0aGUgZGV2aWNlIGdhdmUgeW91IHBlcm1pc3Npb24gLQogICAgICAgIGlmIHlvdSdyZSBydW5uaW5nIGFzIHJvb3QsIGFsbCBiZXRzIGFyZSBvZmYpLgogICAgICA8L3BhcmE+CiAgICAgIDxwYXJhPgogICAgICAgIFNvIHBsZWFzZSBtYWtlIHN1cmUgdGhhdCA8ZW1waGFzaXM+YWxsPC9lbXBoYXNpcz4gU0NTSSBkZXZpY2VzIG5vdCBuZWVkZWQgYnkgdGhlIHByb2dyYW0KICAgICAgICBoYXZlIHRoZWlyIHBlcm1pc3Npb25zIHNldCBhcyByZXN0cmljdGVkIGFzIHBvc3NpYmxlIQogICAgICA8L3BhcmE+CgogICAgICA8cGFyYT4KICAgICAgICBDb29rYm9vayBmb3Igc2V0dGluZyB1cCBzY2FubmVyOiAoQXQgbGVhc3QgaG93IG1pbmUgaXMgdG8gd29yaykKCSh3ZWxsLCBmb3Igb3RoZXIgZGV2aWNlcyBzdWNoIGFzIENEIGJ1cm5lcnMsIE1PIGRyaXZlcywgLi4uLCB0b28pCiAgICAgIDwvcGFyYT4KCiAgICAgIDxzZWN0Mj4KICAgICAgICA8dGl0bGU+V2luZG93cyByZXF1aXJlbWVudHM8L3RpdGxlPgogICAgICAgIDxvcmRlcmVkbGlzdD4KICAgICAgICAgIDxsaXN0aXRlbT4KICAgICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgICAgVGhlIHNjYW5uZXIgc29mdHdhcmUgbmVlZHMgdG8gdXNlIHRoZSAiQWRhcHRlYyIKICAgICAgICAgICAgICBjb21wYXRpYmxlIGRyaXZlcnMgKEFTUEkpLiBBdCBsZWFzdCB3aXRoIE11c3RlaywgdGhleQogICAgICAgICAgICAgIGFsbG93IHlvdSB0aGUgY2hvaWNlIG9mIHVzaW5nIHRoZSBidWlsdC1pbiBjYXJkIG9yIHRoZQogICAgICAgICAgICAgICJBZGFwdGVjIChBSEEpIiBjb21wYXRpYmxlIGRyaXZlcnMuIFRoaXMgd2lsbCBub3Qgd29yawogICAgICAgICAgICAgIGFueSBvdGhlciB3YXkuIFNvZnR3YXJlIHRoYXQgYWNjZXNzZXMgdGhlIHNjYW5uZXIgdmlhIGEKICAgICAgICAgICAgICBET1MgQVNQSSBkcml2ZXIgKGUuZy4gQVNQSTJET1MpIGlzIHN1cHBvcnRlZCwgdG9vLiBbQU1dCiAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgICAgICA8bGlzdGl0ZW0+CiAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgIFlvdSBwcm9iYWJseSBuZWVkIGEgcmVhbCB3aW5kb3dzIGluc3RhbGwgb2YgdGhlIHNvZnR3YXJlCiAgICAgICAgICAgICAgdG8gc2V0IHRoZSBMVU4ncy9TQ1NJIGlkJ3MgdXAgY29ycmVjdGx5LiBJJ20gbm90IGV4YWN0bHkKICAgICAgICAgICAgICBzdXJlLgogICAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8L2xpc3RpdGVtPgogICAgICAgIDwvb3JkZXJlZGxpc3Q+CiAgICAgIDwvc2VjdDI+CgogICAgICA8c2VjdDI+CiAgICAgICAgPHRpdGxlPkxpbnV4IHJlcXVpcmVtZW50czwvdGl0bGU+CiAgICAgICAgPG9yZGVyZWRsaXN0PgogICAgICAgICAgPGxpc3RpdGVtPgogICAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgICBZb3VyIFNDU0kgY2FyZCBtdXN0IGJlIHN1cHBvcnRlZCB1bmRlciBMaW51eC4gVGhpcyB3aWxsCiAgICAgICAgICAgICAgbm90IHdvcmsgd2l0aCBhbiB1bmtub3duIFNDU0kgY2FyZC4gRXZlbiBmb3IgY2hlYXAnbgogICAgICAgICAgICAgIGNyYXBweSAic2Nhbm5lciBvbmx5IiBjb250cm9sbGVycyBzb21lIHNwZWNpYWwgTGludXgKICAgICAgICAgICAgICBkcml2ZXJzIGV4aXN0IG9uIHRoZSBuZXQuCgkgICAgICBJZiB5b3UgaW50ZW5kIHRvIHVzZSB5b3VyIElERSBkZXZpY2UsIHlvdSBuZWVkIHRvIHVzZSB0aGUKCSAgICAgIGlkZS1zY3NpIGVtdWxhdGlvbi4KCSAgICAgIFJlYWQKCSAgICAgIDx1bGluayB1cmw9Imh0dHA6Ly93d3cubGludXhkb2Mub3JnL0hPV1RPL0NELVdyaXRpbmctSE9XVE8uaHRtbCI+CgkgICAgICAgICAgICAgICAgICBodHRwOi8vd3d3LmxpbnV4ZG9jLm9yZy9IT1dUTy9DRC1Xcml0aW5nLUhPV1RPLmh0bWw8L3VsaW5rPgoJICAgICAgZm9yIGlkZS1zY3NpIHNldHVwIGluc3RydWN0aW9ucy4KICAgICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPC9saXN0aXRlbT4KICAgICAgICAgIDxsaXN0aXRlbT4KICAgICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgICAgQ29tcGlsZSBnZW5lcmljIFNDU0kgZHJpdmVycyBpbnRvIHlvdXIga2VybmVsLgogICAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8L2xpc3RpdGVtPgogICAgICAgICAgPGxpc3RpdGVtPgogICAgICAgICAgICA8cGFyYT4KCSAgICAgIFRoaXMgc2VlbXMgdG8gYmUgbm90IHJlcXVpcmVkIGFueSBtb3JlIGZvciBuZXdlciAoMi4yLngpIGtlcm5lbHM6CiAgICAgICAgICAgICAgTGludXggYnkgZGVmYXVsdCB1c2VzIHNtYWxsZXIgU0NTSSBidWZmZXJzIHRoYW4gV2luZG93cy4KICAgICAgICAgICAgICBUaGVyZSBpcyBhIGtlcm5lbCBidWlsZCBkZWZpbmUgPGxpdGVyYWw+U0dfQklHX0JVRkY8L2xpdGVyYWw+IChpbgogICAgICAgICAgICAgIDxmaWxlbmFtZT5zZy5oPC9maWxlbmFtZT4pIHRoYXQgaXMgYnkgZGVmYXVsdCBzZXQgdG9vCiAgICAgICAgICAgICAgbG93LiBUaGUgU0FORSBwcm9qZWN0IHJlY29tbWVuZHMKICAgICAgICAgICAgICA8bGl0ZXJhbD4xMzA1NjA8L2xpdGVyYWw+IGFuZCB0aGlzIHNlZW1zIHRvIHdvcmsganVzdAogICAgICAgICAgICAgIGZpbmUuIFRoaXMgZG9lcyByZXF1aXJlIGEga2VybmVsIHJlYnVpbGQuCiAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgICAgICA8bGlzdGl0ZW0+CiAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgIE1ha2UgdGhlIGRldmljZXMgZm9yIHRoZSBzY2FubmVyIChnZW5lcmljIFNDU0kgZGV2aWNlcykKICAgICAgICAgICAgICAtIGxvb2sgYXQgdGhlIFNDU0kgcHJvZ3JhbW1pbmcgSE9XVE8gYXQKICAgICAgICAgICAgICA8dWxpbmsgdXJsPSJodHRwOi8vd3d3LmxpbnV4ZG9jLm9yZy9IT1dUTy9TQ1NJLVByb2dyYW1taW5nLUhPV1RPLmh0bWwiPgoJCQkgIGh0dHA6Ly93d3cubGludXhkb2Mub3JnL0hPV1RPL1NDU0ktUHJvZ3JhbW1pbmctSE9XVE8uaHRtbDwvdWxpbms+CgkgICAgICBmb3IgZGV2aWNlIG51bWJlcmluZy4KICAgICAgICAgICAgPC9wYXJhPgogICAgICAgICAgPC9saXN0aXRlbT4KICAgICAgICAgIDxsaXN0aXRlbT4KICAgICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgICAgSSB3b3VsZCByZWNvbW1lbmQgbWFraW5nIHRoZSBzY2FubmVyIGRldmljZSB3cml0YWJsZSBieQogICAgICAgICAgICAgIGEgZ3JvdXAuIEkgbWFkZSBhIGdyb3VwIGNhbGxlZAogICAgICAgICAgICAgIDxsaXRlcmFsPnNjYW5uZXI8L2xpdGVyYWw+IGFuZCBhZGRlZCBteXNlbGYgdG8gaXQuCiAgICAgICAgICAgICAgUnVubmluZyBhcyByb290IGluY3JlYXNlcyB5b3VyIHJpc2sgb2Ygc2VuZGluZyBiYWQgU0NTSQogICAgICAgICAgICAgIGNvbW1hbmRzIHRvIHRoZSB3cm9uZyBkZXZpY2UuIFdpdGggYSByZWd1bGFyIHVzZXIsIHlvdQogICAgICAgICAgICAgIGFyZSBiZXR0ZXIgcHJvdGVjdGVkLgogICAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8L2xpc3RpdGVtPgogICAgICAgICAgPGxpc3RpdGVtPgogICAgICAgICAgICA8cGFyYT4KCSAgICAgIEZvciBXaW4zMiBzb2Z0d2FyZSAoV05BU1BJMzIpLCBXaW5lIGhhcyBhdXRvLWRldGVjdGlvbiBpbiBwbGFjZS4KCSAgICAgIEZvciBXaW4xNiBzb2Z0d2FyZSAoV0lOQVNQSSksIHlvdSBuZWVkIHRvIGFkZCBhIFNDU0kgZGV2aWNlIGVudHJ5CgkgICAgICBmb3IgeW91ciBwYXJ0aWN1bGFyIHNjYW5uZXIgdG8gfi8ud2luZS9jb25maWcuIFRoZSBmb3JtYXQgaXMKCSAgICAgIDxsaXRlcmFsPltzY3NpIGNDdFRkRF08L2xpdGVyYWw+IHdoZXJlCiAgICAgICAgICAgICAgPGxpdGVyYWw+IkMiID0gImNvbnRyb2xsZXIiPC9saXRlcmFsPiwKICAgICAgICAgICAgICA8bGl0ZXJhbD4iVCIgPSAidGFyZ2V0IjwvbGl0ZXJhbD4sIDxsaXRlcmFsPkQ9TFVOPC9saXRlcmFsPgogICAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgIEZvciBleGFtcGxlLCBJIHNldCBtaW5lIHVwIGFzICBjb250cm9sbGVyIDxsaXRlcmFsPjA8L2xpdGVyYWw+LAogICAgICAgICAgICAgIFRhcmdldCA8bGl0ZXJhbD42PC9saXRlcmFsPiwgTFVOIDxsaXRlcmFsPjA8L2xpdGVyYWw+LgogICAgICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4KW3Njc2kgYzB0NmQwXQoiRGV2aWNlIiA9ICIvZGV2L3NnaSIKICAgICAgICAgICAgICA8L3Byb2dyYW1saXN0aW5nPgogICAgICAgICAgICAgIFlvdXJzIHdpbGwgdmFyeSB3aXRoIHlvdXIgcGFydGljdWxhciBTQ1NJIHNldHVwLgogICAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8L2xpc3RpdGVtPgogICAgICAgIDwvb3JkZXJlZGxpc3Q+CiAgICAgIDwvc2VjdDI+CgogICAgICA8c2VjdDI+CiAgICAgICAgPHRpdGxlPkdlbmVyYWwgSW5mb3JtYXRpb248L3RpdGxlPgogICAgICAgIDxwYXJhPgogICAgICAgICAgVGhlIG11c3RlayBzY2FubmVyIEkgaGF2ZSB3YXMgc2hpcHBlZCB3aXRoIGEgcGFja2FnZQogICAgICAgICAgImlwcGx1cyIuIFRoaXMgcHJvZ3JhbSB1c2VzIHRoZSBUV0FJTiBkcml2ZXIgc3BlY2lmaWNhdGlvbgogICAgICAgICAgdG8gYWNjZXNzIHNjYW5uZXJzLgogICAgICAgIDwvcGFyYT4KICAgICAgICA8cGFyYT4KICAgICAgICAgIChUV0FJTiBNQU5BR0VSKQogICAgICAgIDwvcGFyYT4KICAgICAgICA8cGFyYT4KICAgICAgICAgIDxwcm9ncmFtbGlzdGluZz4KaXBwbHVzLmV4ZSAmbHQ7LSZndDsgKFRXQUlOIElOVEVSRkFDRSkgJmx0Oy0mZ3Q7IChUV0FJTiBEQVRBIFNPVVJDRS5BU1BJKSAtJmd0OyBXSU5BU1BJCiAgICAgICAgICA8L3Byb2dyYW1saXN0aW5nPgogICAgICAgIDwvcGFyYT4KICAgICAgPC9zZWN0Mj4KCiAgICAgIDxzZWN0Mj4KICAgICAgICA8dGl0bGU+Tk9URVMvQlVHUzwvdGl0bGU+CiAgICAgICAgPHBhcmE+CiAgICAgICAgICBUaGUgYmlnZ2VzdCBkcndiYWNrIGlzIHRoYXQgaXQgb25seSB3b3JrcyB1bmRlciBMaW51eCBhdCB0aGUgbW9tZW50LgogICAgICAgIDwvcGFyYT4KICAgICAgICA8cGFyYT4KICAgICAgICAgIFRoZSBBU1BJIGNvZGUgaGFzIG9ubHkgYmVlbiB0ZXN0ZWQgd2l0aDoKICAgICAgICA8L3BhcmE+CiAgICAgICAgPGl0ZW1pemVkbGlzdD4KICAgICAgICAgIDxsaXN0aXRlbT4KICAgICAgICAgICAgPHBhcmE+CiAgICAgICAgICAgICAgYSBNdXN0ZWsgODAwU1Agd2l0aCBhIEJ1c2xvZ2ljIGNvbnRyb2xsZXIgdW5kZXIgTGludXggW0JNXQogICAgICAgICAgICA8L3BhcmE+CiAgICAgICAgICA8L2xpc3RpdGVtPgogICAgICAgICAgPGxpc3RpdGVtPgogICAgICAgICAgICA8cGFyYT4KICAgICAgICAgICAgICBhIFNpZW1lbnMgTml4ZG9yZiA5MDM2IHdpdGggQWRhcHRlYyBBVkEtMTUwNSB1bmRlciBMaW51eAogICAgICAgICAgICAgIGFjY2Vzc2VkIHZpYSBET1NBU1BJLiBOb3RlIHRoYXQgSSBoYWQgY29sb3IgcHJvYmxlbXMsCiAgICAgICAgICAgICAgdGhvdWdoIChiYXJlbHkgcmVhZGFibGUgcmVzdWx0KSBbQU1dCiAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgICAgICA8bGlzdGl0ZW0+CiAgICAgICAgICAgIDxwYXJhPgogICAgICAgICAgICAgIGEgRnVqaXRzdSBNMjUxM0EgTU8gZHJpdmUgKDY0ME1CKSB1c2luZyBnZW5lcmljIFNDU0kKICAgICAgICAgICAgICBkcml2ZXJzLiBGb3JtYXR0aW5nIGFuZCBlamVjdGluZyB3b3JrZWQgcGVyZmVjdGx5LgogICAgICAgICAgICAgIFRoYW5rcyB0byBVd2UgQm9ubmVzIGZvciBhY2Nlc3MgdG8gdGhlIGhhcmR3YXJlISBbQU1dCiAgICAgICAgICAgIDwvcGFyYT4KICAgICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgICAgPC9pdGVtaXplZGxpc3Q+CiAgICAgICAgPHBhcmE+CiAgICAgICAgICBJIG1ha2Ugbm8gd2FycmFudHkgdG8gdGhlIEFTUEkgY29kZS4gSXQgbWFrZXMgbXkgc2Nhbm5lcgogICAgICAgICAgd29yay4gWW91ciBkZXZpY2VzIG1heSBleHBsb2RlLiBJIGhhdmUgbm8gd2F5IG9mIGRldGVybWluaW5nCiAgICAgICAgICB0aGlzLiBJIHRha2UgemVybyByZXNwb25zaWJpbGl0eSEKICAgICAgICA8L3BhcmE+CiAgICAgIDwvc2VjdDI+CiAgICA8L3NlY3QxPgoKICAgIDxzZWN0MSBpZD0iY29uZmlnLW9kYmMiPgogICAgICA8dGl0bGU+VXNpbmcgT0RCQzwvdGl0bGU+CiAgICAgIDxwYXJhPgogICAgICAgIFRoaXMgc2VjdGlvbiBkZXNjcmliZXMgaG93IE9EQkMgd29ya3Mgd2l0aGluIFdpbmUgYW5kIGhvdyB0byBjb25maWd1cmUKICAgICAgICBpdCB0byBkbyB3aGF0IHlvdSB3YW50IChpZiBpdCBjYW4gZG8gd2hhdCB5b3Ugd2FudCkuCiAgICAgIDwvcGFyYT4KICAgICAgPHBhcmE+CiAgICAgICAgVGhlIE9EQkMgc3lzdGVtIHdpdGhpbiBXaW5lLCBhcyB3aXRoIHRoZSBwcmludGluZyBzeXN0ZW0sIGlzIGRlc2lnbmVkCiAgICAgICAgdG8gaG9vayBhY3Jvc3MgdG8gdGhlIFVuaXggc3lzdGVtIGF0IGEgaGlnaCBsZXZlbC4gIFJhdGhlciB0aGFuCiAgICAgICAgZW5zdXJpbmcgdGhhdCBhbGwgdGhlIHdpbmRvd3MgY29kZSB3b3JrcyB1bmRlciB3aW5lIGl0IHVzZXMgYSBzdWl0YWJsZQogICAgICAgIFVuaXggT0RCQyBwcm92aWRlciwgc3VjaCBhcyBVbml4T0RCQy4gIFRodXMgaWYgeW91IGNvbmZpZ3VyZSBXaW5lIHRvCiAgICAgICAgdXNlIHRoZSBidWlsdC1pbiBvZGJjMzIuZGxsLCB0aGF0IFdpbmUgRExMIHdpbGwgaW50ZXJmYWNlIHRvIHlvdXIKICAgICAgICBVbml4IE9EQkMgcGFja2FnZSBhbmQgbGV0IHRoYXQgZG8gdGhlIHdvcmssIHdoZXJlYXMgaWYgeW91IGNvbmZpZ3VyZQogICAgICAgIFdpbmUgdG8gdXNlIHRoZSBuYXRpdmUgb2RiYzMyLmRsbCBpdCB3aWxsIHRyeSB0byB1c2UgdGhlIG5hdGl2ZQogICAgICAgIE9EQkMzMiBkcml2ZXJzIGV0Yy4KICAgICAgPC9wYXJhPgogICAgICA8c2VjdDI+CiAgICAgICAgPHRpdGxlPlVzaW5nIGEgVW5peCBPREJDIHN5c3RlbSB3aXRoIFdpbmU8L3RpdGxlPgogICAgICAgIDxwYXJhPgogICAgICAgICAgVGhlIGZpcnN0IHN0ZXAgaW4gdXNpbmcgYSBVbml4IE9EQkMgc3lzdGVtIHdpdGggV2luZSBpcywgb2YgY291cnNlLAogICAgICAgICAgdG8gZ2V0IHRoZSBVbml4IE9EQkMgc3lzdGVtIHdvcmtpbmcgaXRzZWxmLiAgVGhpcyBtYXkgaW52b2x2ZQogICAgICAgICAgZG93bmxvYWRpbmcgY29kZSBvciBSUE1zIGV0Yy4gIFRoZXJlIGFyZSBzZXZlcmFsIFVuaXggT0RCQyBzeXN0ZW1zCiAgICAgICAgICBhdmFpbGFibGU7IHRoZSBvbmUgdGhlIGF1dGhvciBpcyB1c2VkIHRvIGlzIHVuaXhPREJDICh3aXRoIHRoZQogICAgICAgICAgSUJNIERCMiBkcml2ZXIpLiBUeXBpY2FsbHkgc3VjaCBzeXN0ZW1zIHdpbGwgaW5jbHVkZSBhIHRvb2wsIHN1Y2gKICAgICAgICAgIGFzIDxjb21tYW5kPmlzcWw8L2NvbW1hbmQ+LCB3aGljaCB3aWxsIGFsbG93IHlvdSB0byBhY2Nlc3MgdGhlIGRhdGEgZnJvbSB0aGUgY29tbWFuZAogICAgICAgICAgbGluZSBzbyB0aGF0IHlvdSBjYW4gY2hlY2sgdGhhdCB0aGUgc3lzdGVtIGlzIHdvcmtpbmcuCiAgICAgICAgPC9wYXJhPgogICAgICAgIDxwYXJhPgogICAgICAgICAgVGhlIG5leHQgc3RlcCBpcyB0byBob29rIHRoZSBVbml4IE9EQkMgbGlicmFyeSB0byB0aGUgd2luZSBidWlsdC1pbgogICAgICAgICAgb2RiYzMyIERMTC4gIFRoZSBidWlsdC1pbiBvZGJjMzIgKGN1cnJlbnRseSkgbG9va3MgdG8gdGhlCiAgICAgICAgICBlbnZpcm9ubWVudCB2YXJpYWJsZSA8ZW1waGFzaXM+TElCX09EQkNfRFJJVkVSX01BTkFHRVI8L2VtcGhhc2lzPgogICAgICAgICAgZm9yIHRoZSBuYW1lIG9mIHRoZSBPREJDIGxpYnJhcnkuICBGb3IgZXhhbXBsZSBpbiB0aGUgYXV0aG9yJ3MKICAgICAgICAgIC5iYXNocmMgZmlsZSBpcyB0aGUgbGluZToKICAgICAgICA8L3BhcmE+CiAgICAgICAgPHByb2dyYW1saXN0aW5nPgpleHBvcnQgTElCX09EQkNfRFJJVkVSX01BTkFHRVI9L3Vzci9saWIvbGlib2RiYy5zby4xLjAuMAogICAgICAgIDwvcHJvZ3JhbWxpc3Rpbmc+CiAgICAgICAgPHBhcmE+CiAgICAgICAgICBJZiB0aGF0IGVudmlyb25tZW50IHZhcmlhYmxlIGlzIG5vdCBzZXQgdGhlbiBpdCBsb29rcyBmb3IgYQogICAgICAgICAgbGlicmFyeSBjYWxsZWQgbGlib2RiYy5zbyBhbmQgc28geW91IGNhbiBhZGQgYSBzeW1ib2xpYyBsaW5rIHRvCiAgICAgICAgICBlcXVhdGUgdGhhdCB0byB5b3VyIG93biBsaWJyYXJ5LiAgRm9yIGV4YW1wbGUgYXMgcm9vdCB5b3UgY291bGQKICAgICAgICAgIHJ1biB0aGUgY29tbWFuZHM6CiAgICAgICAgPC9wYXJhPgogICAgICAgIDxzY3JlZW4+Cjxwcm9tcHQ+IyA8L3Byb21wdD48dXNlcmlucHV0PmxuIC1zIGxpYm9kYmMuc28uMS4wLjAgL3Vzci9saWIvbGlib2RiYy5zbzwvdXNlcmlucHV0Pgo8cHJvbXB0PiMgPC9wcm9tcHQ+PHVzZXJpbnB1dD4vc2Jpbi9sZGNvbmZpZzwvdXNlcmlucHV0PgogICAgICAgIDwvc2NyZWVuPgogICAgICAgIDxwYXJhPgogICAgICAgICAgVGhlIGxhc3Qgc3RlcCBpbiBjb25maWd1cmluZyB0aGlzIGlzIHRvIGVuc3VyZSB0aGF0IFdpbmUgaXMgc2V0IHVwCiAgICAgICAgICB0byBydW4gdGhlIGJ1aWx0LWluIHZlcnNpb24gb2Ygb2RiYzMyLmRsbCwgYnkgbW9kaWZ5aW5nIHRoZSBETEwKICAgICAgICAgIGNvbmZpZ3VyYXRpb24uICBUaGlzIGJ1aWx0LWluIERMTCBtZXJlbHkgYWN0cyBhcyBhIHN0dWIgYmV0d2VlbiB0aGUKICAgICAgICAgIGNhbGxpbmcgY29kZSBhbmQgdGhlIFVuaXggT0RCQyBsaWJyYXJ5LgogICAgICAgIDwvcGFyYT4KICAgICAgICA8cGFyYT4KICAgICAgICAgIElmIHlvdSBoYXZlIGFueSBwcm9ibGVtcyB0aGVuIHlvdSBjYW4gdXNlIHRoZSBkZWJ1Z21zZyBjaGFubmVsCiAgICAgICAgICBvZGJjMzIgdG8gdHJhY2Ugd2hhdCBpcyBoYXBwZW5pbmcuICBPbmUgd29yZCBvZiB3YXJuaW5nLiAgU29tZQogICAgICAgICAgcHJvZ3JhbXMgYWN0dWFsbHkgY2hlYXQgYSBsaXR0bGUgYW5kIGJ5cGFzcyB0aGUgT0RCQyBsaWJyYXJ5LiAgRm9yCiAgICAgICAgICBleGFtcGxlIHRoZSBDcnlzdGFsIFJlcG9ydHMgZW5naW5lIGdvZXMgdG8gdGhlIHJlZ2lzdHJ5IHRvIGNoZWNrIG9uCiAgICAgICAgICB0aGUgRFNOLiAgVGhlIGZpeCBmb3IgdGhpcyBpcyBkb2N1bWVudGVkIGF0IHVuaXhPREJDJ3Mgc2l0ZSB3aGVyZQogICAgICAgICAgdGhlcmUgaXMgYSBzZWN0aW9uIG9uIHVzaW5nIHVuaXhPREJDIHdpdGggV2luZS4KICAgICAgICA8L3BhcmE+CiAgICAgIDwvc2VjdDI+CiAgICAgIDxzZWN0Mj4KICAgICAgICA8dGl0bGU+VXNpbmcgV2luZG93cyBPREJDIGRyaXZlcnM8L3RpdGxlPgogICAgICAgIDxwYXJhPgogICAgICAgICAgRG9lcyBhbnlvbmUgYWN0dWFsbHkgaGF2ZSBhbnkgZXhwZXJpZW5jZSBvZiB0aGlzIGFuZCBhbnl0aGluZyB0bwogICAgICAgICAgYWRkPwogICAgICAgIDwvcGFyYT4KICAgICAgPC9zZWN0Mj4KICAgIDwvc2VjdDE+CgogIDwvY2hhcHRlcj4KCjwhLS0gS2VlcCB0aGlzIGNvbW1lbnQgYXQgdGhlIGVuZCBvZiB0aGUgZmlsZQpMb2NhbCB2YXJpYWJsZXM6Cm1vZGU6IHNnbWwKc2dtbC1wYXJlbnQtZG9jdW1lbnQ6KCJ3aW5lLXVzZXIuc2dtbCIgInNldCIgImJvb2siICJjaGFwdGVyIiAiIikKRW5kOgotLT4K