https://www.basilica.ai/_next/static/chunks/3067.45c84ffdac7210e7.js

1"use strict";(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[3067],{3067:function(A,G,B){B.r(G),B.d(G,{default:function(){return Z}});var Z="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

1ZlYWxpbmcgdGhlIHdlaWdodHMulC0gKipuZXR1aWQqKjogVGhlIG5ldHdvcmsgaWRlbnRpZmllci5BAS0gKipyZXZlYWxlZF9oYXNoZXMqKjogQSB2ZWN0b3Igb2YgaGFzaGVzIHJlcHJlc2VudGluZyBlYWNoIHJldmVhbGVkIHdlaWdodCBzZXQuVEJhdGNoV2VpZ2h0c0NvbXBsZXRlZAgAvAFQVmVjPENvbXBhY3Q8TmV0VWlkPj4AAAABMFQ6OkFjY291bnRJZABTENBBIGJhdGNoIG9mIHdlaWdodHMgKG9yIGNvbW1pdHMpIGhhdmUgYmVlbiBmb3JjZS1zZXQuADUBLSAqKm5ldHVpZHMqKjogVGhlIG5ldHVpZHMgdGhlc2Ugd2VpZ2h0cyB3ZXJlIHN1Y2Nlc3NmdWxseSBzZXQvY29tbWl0dGVkIGZvci6oLSAqKndobyoqOiBUaGUgaG90a2V5IHRoYXQgc2V0IHRoaXMgYmF0Y2guYEJhdGNoQ29tcGxldGVkV2l0aEVycm9ycwBUBMRBIGJhdGNoIGV4dHJpbnNpYyBjb21wbGV0ZWQgYnV0IHdpdGggc29tZSBlcnJvcnMuVEJhdGNoV2VpZ2h0SXRlbUZhaWxlZAQAaAFkc3BfcnVudGltZTo6RGlzcGF0Y2hFcnJvcgBVDLRBIHdlaWdodCBzZXQgYW1vbmcgYSBiYXRjaCBvZiB3ZWlnaHRzIGZhaWxlZC4A7C0gKiplcnJvcioqOiBUaGUgZGlzcGF0Y2ggZXJyb3IgZW1pdHRlZCBieSB0aGUgZmFpbGVkIGl0ZW0uQFN0YWtlVHJhbnNmZXJyZWQYAAABMFQ6OkFjY291bnRJZAAAAAEwVDo6QWNjb3VudElkAAAAATBUOjpBY2NvdW50SWQAAKABGE5ldFVpZAAAoAEYTmV0VWlkAAAYASxUYW9DdXJyZW5jeQBWDCkBU3Rha2UgaGFzIGJlZW4gdHJhbnNmZXJyZWQgZnJvbSBvbmUgY29sZGtleSB0byBhbm90aGVyIG9uIHRoZSBzYW1lIHN1Ym5ldC4sUGFyYW1ldGVyczphAShvcmlnaW5fY29sZGtleSwgZGVzdGluYXRpb25fY29sZGtleSwgaG90a2V5LCBvcmlnaW5fbmV0dWlkLCBkZXN0aW5hdGlvbl9uZXR1aWQsIGFtb3VudCkwU3Rha2VTd2FwcGVkFAAAATBUOjpBY2NvdW50SWQAAAABMFQ6OkFjY291bnRJZAAAoAEYTmV0VWlkAACgARhOZXRVaWQAABgBLFRhb0N1cnJlbmN5AFcQTQFTdGFrZSBoYXMgYmVlbiBzd2FwcGVkIGZyb20gb25lIHN1Ym5ldCB0byBhbm90aGVyIGZvciB0aGUgc2FtZSBjb2xka2V5LWhvdGtleSBwYWlyLgAsUGFyYW1ldGVyczrwKGNvbGRrZXksIGhvdGtleSwgb3JpZ2luX25ldHVpZCwgZGVzdGluYXRpb25fbmV0dWlkLCBhbW91bnQpOFRyYW5zZmVyVG9nZ2xlCACgARhOZXRVaWQAACQBEGJvb2wAWBDIRXZlbnQgY2FsbGVkIHdoZW4gdHJhbnNmZXIgaXMgdG9nZ2xlZCBvbiBhIHN1Ym5ldC4ALFBhcmFtZXRlcnM6OChuZXR1aWQsIGJvb2wpUFN1Ym5ldE93bmVySG90a2V5U2V0CACgARhOZXRVaWQAAAABMFQ6OkFjY291bnRJZABZEKxUaGUgb3duZXIgaG90a2V5IGZvciBhIHN1Ym5ldCBoYXMgYmVlbiBzZXQuACxQYXJhbWV0ZXJzOlAobmV0dWlkLCBuZXdfaG90a2V5KWxGaXJzdEVtaXNzaW9uQmxvY2tOdW1iZXJTZXQIAKABGE5ldFVpZAAAGAEMdTY0AFoU4EZpcnN0RW1pc3Npb25CbG9ja051bWJlciBpcyBzZXQgdmlhIHN0YXJ0IGNhbGwgZXh0cmluc2ljACxQYXJhbWV0ZXJzOhhuZXR1aWQwYmxvY2sgbnVtYmVyNEFscGhhUmVjeWNsZWQQAAABMFQ6OkFjY291bnRJZAAAAAEwVDo6QWNjb3VudElkAAAYATRBbHBoYUN1cnJlbmN5AACgARhOZXRVaWQAWxDcQWxwaGEgaGFzIGJlZW4gcmVjeWNsZWQsIHJlZHVjaW5nIEFscGhhT3V0IG9uIGEgc3VibmV0LgAsUGFyYW1ldGVyczqQKGNvbGRrZXksIGhvdGtleSwgYW1vdW50LCBzdWJuZXRfaWQpLEFscGhhQnVybmVkEAAAATBUOjpBY2NvdW50SWQAAAABMFQ6OkFjY291bnRJZAAAGAE0QWxwaGFDdXJyZW5jeQAAoAEYTmV0VWlkAFwQxEFscGhhIGhhdmUgYmVlbiBidXJuZWQgd2l0aG91dCByZWR1Y2luZyBBbHBoYU91dC4ALFBhcmFtZXRlcnM6kChjb2xka2V5LCBob3RrZXksIGFtb3VudCwgc3VibmV0X2lkKUBFdm1LZXlBc3NvY2lhdGVkEAEYbmV0dWlkoAEYTmV0VWlkBJhUaGUgc3VibmV0IHRoYXQgdGhlIGhvdGtleSBiZWxvbmdzIHRvLgEYaG90a2V5AAEwVDo6QWNjb3VudElkBJxUaGUgaG90a2V5IGFzc29jaWF0ZWQgd2l0aCB0aGUgRVZNIGtleS4BHGV2bV9rZXnEARBIMTYwBLRUaGUgRVZNIGtleSBiZWluZyBhc3NvY2lhdGVkIHdpdGggdGhlIGhvdGtleS4BQGJsb2NrX2Fzc29jaWF0ZWQYAQx1NjQEpFRoZSBibG9jayB3aGVyZSB0aGUgYXNzb2NpYXRpb24gaGFwcGVuZWQuXQS0QW4gRVZNIGtleSBoYXMgYmVlbiBhc3NvY2lhdGVkIHdpdGggYSBob3RrZXkuTENSVjNXZWlnaHRzUmV2ZWFsZWQIAKABGE5ldFVpZAAAAAEwVDo6QWNjb3VudElkAF4QtENSVjMgV2VpZ2h0cyBoYXZlIGJlZW4gc3VjY2Vzc2Z1bGx5IHJldmVhbGVkLgCULSAqKm5ldHVpZCoqOiBUaGUgbmV0d29yayBpZGVudGlmaWVyLvAtICoqd2hvKio6IFRoZSBhY2NvdW50IElEIG9mIHRoZSB1c2VyIHJldmVhbGluZyB0aGUgd2VpZ2h0cy5YQ29tbWl0UmV2ZWFsUGVyaW9kc1NldAgAoAEYTmV0VWlkAAAYAQx1NjQAXxDAQ29tbWl0LVJldmVhbCBwZXJpb2RzIGhhcyBiZWVuIHN1Y2Nlc3NmdWxseSBzZXQuAJQtICoqbmV0dWlkKio6IFRoZSBuZXR3b3JrIGlkZW50aWZpZXIu2C0gKipwZXJpb2RzKio6IFRoZSBudW1iZXIgb2YgZXBvY2hzIGJlZm9yZSB0aGUgcmV2ZWFsLkxDb21taXRSZXZlYWxFbmFibGVkCACgARhOZXRVaWQAACQBEGJvb2wAYBCwQ29tbWl0LVJldmVhbCBoYXMgYmVlbiBzdWNjZXNzZnVsbHkgdG9nZ2xlZC4AlC0gKipuZXR1aWQqKjogVGhlIG5ldHdvcmsgaWRlbnRpZmllci6gLSAqKkVuYWJsZWQqKjogSXMgQ29tbWl0LVJldmVhbCBlbmFibGVkLlRIb3RrZXlTd2FwcGVkT25TdWJuZXQQARxjb2xka2V5AAEwVDo6QWNjb3VudElkBGR0aGUgYWNjb3VudCBJRCBvZiBjb2xka2V5AShvbGRfaG90a2V5AAEwVDo6QWNjb3VudElkBHB0aGUgYWNjb3VudCBJRCBvZiBvbGQgaG90a2V5AShuZXdfaG90a2V5AAEwVDo6QWNjb3VudElkBHB0aGUgYWNjb3VudCBJRCBvZiBuZXcgaG90a2V5ARhuZXR1aWSgARhOZXRVaWQENHRoZSBzdWJuZXQgSURhBFR0aGUgaG90a2V5IGlzIHN3YXBwZWRIU3VibmV0TGVhc2VDcmVhdGVkEAEsYmVuZWZpY2lhcnkAATBUOjpBY2NvdW50SWQEdFRoZSBiZW5lZmljaWFyeSBvZiB0aGUgbGVhc2UuAS

1BsZWFzZV9pZBABHExlYXNlSWQEMFRoZSBsZWFzZSBJRAEYbmV0dWlkoAEYTmV0VWlkBDRUaGUgc3VibmV0IElEASRlbmRfYmxvY2vMAWRPcHRpb248QmxvY2tOdW1iZXJGb3I8VD4+BGhUaGUgZW5kIGJsb2NrIG9mIHRoZSBsZWFzZWIEgEEgc3VibmV0IGxlYXNlIGhhcyBiZWVuIGNyZWF0ZWQuVFN1Ym5ldExlYXNlVGVybWluYXRlZAgBLGJlbmVmaWNpYXJ5AAEwVDo6QWNjb3VudElkBHRUaGUgYmVuZWZpY2lhcnkgb2YgdGhlIGxlYXNlLgEYbmV0dWlkoAEYTmV0VWlkBDRUaGUgc3VibmV0IElEYwSMQSBzdWJuZXQgbGVhc2UgaGFzIGJlZW4gdGVybWluYXRlZC40U3ltYm9sVXBkYXRlZAgBGG5ldHVpZKABGE5ldFVpZAQ0VGhlIHN1Ym5ldCBJRAEYc3ltYm9sOAEcVmVjPHU4PgSEVGhlIHN5bWJvbCB0aGF0IGhhcyBiZWVuIHVwZGF0ZWQuZASkVGhlIHN5bWJvbCBmb3IgYSBzdWJuZXQgaGFzIGJlZW4gdXBkYXRlZC5YQ29tbWl0UmV2ZWFsVmVyc2lvblNldAQAoAEMdTE2AGUMvENvbW1pdCBSZXZlYWwgV2VpZ2h0cyB2ZXJzaW9uIGhhcyBiZWVuIHVwZGF0ZWQuAJAtICoqdmVyc2lvbioqOiBUaGUgcmVxdWlyZWQgdmVyc2lvbi5oVGltZWxvY2tlZFdlaWdodHNDb21taXR0ZWQQAAABMFQ6OkFjY291bnRJZAAAoAFITmV0VWlkU3RvcmFnZUluZGV4AAA0ARBIMjU2AAAYAQx1NjQAZhjQVGltZWxvY2tlZCB3ZWlnaHRzIGhhdmUgYmVlbiBzdWNjZXNzZnVsbHkgY29tbWl0dGVkLgD0LSAqKndobyoqOiBUaGUgYWNjb3VudCBJRCBvZiB0aGUgdXNlciBjb21taXR0aW5nIHRoZSB3ZWlnaHRzLpQtICoqbmV0dWlkKio6IFRoZSBuZXR3b3JrIGlkZW50aWZpZXIu/C0gKipjb21taXRfaGFzaCoqOiBUaGUgaGFzaCByZXByZXNlbnRpbmcgdGhlIGNvbW1pdHRlZCB3ZWlnaHRzLvwtICoqcmV2ZWFsX3JvdW5kKio6IFRoZSByb3VuZCBhdCB3aGljaCB3ZWlnaHRzIGNhbiBiZSByZXZlYWxlZC5kVGltZWxvY2tlZFdlaWdodHNSZXZlYWxlZAgAoAFITmV0VWlkU3RvcmFnZUluZGV4AAAAATBUOjpBY2NvdW50SWQAZxDMVGltZWxvY2tlZCBXZWlnaHRzIGhhdmUgYmVlbiBzdWNjZXNzZnVsbHkgcmV2ZWFsZWQuAJQtICoqbmV0dWlkKio6IFRoZSBuZXR3b3JrIGlkZW50aWZpZXIu8C0gKip3aG8qKjogVGhlIGFjY291bnQgSUQgb2YgdGhlIHVzZXIgcmV2ZWFsaW5nIHRoZSB3ZWlnaHRzLjhBdXRvU3Rha2VBZGRlZBQBGG5ldHVpZKABGE5ldFVpZARIU3VibmV0IGlkZW50aWZpZXIuASxkZXN0aW5

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

1oZSB2ZXJzaW9uIG51bWJlciBpbmNyZWFzZXMuIE5vdPByZWNvbW1lbmRlZCBmb3Igbm9ybWFsIHVzZS4gVXNlIGBhdXRob3JpemVfdXBncmFkZWAgaW5zdGVhZC4AfFRoaXMgY2FsbCByZXF1aXJlcyBSb290IG9yaWdpbi5gYXBwbHlfYXV0aG9yaXplZF91cGdyYWRlBAEQY29kZTgBHFZlYzx1OD4ACyRVAVByb3ZpZGUgdGhlIHByZWltYWdlIChydW50aW1lIGJpbmFyeSkgYGNvZGVgIGZvciBhbiB1cGdyYWRlIHRoYXQgaGFzIGJlZW4gYXV0aG9yaXplZC4ASQFJZiB0aGUgYXV0aG9yaXphdGlvbiByZXF1aXJlZCBhIHZlcnNpb24gY2hlY2ssIHRoaXMgY2FsbCB3aWxsIGVuc3VyZSB0aGUgc3BlYyBuYW1l6HJlbWFpbnMgdW5jaGFuZ2VkIGFuZCB0aGF0IHRoZSBzcGVjIHZlcnNpb24gaGFzIGluY3JlYXNlZC4AWQFEZXBlbmRpbmcgb24gdGhlIHJ1bnRpbWUncyBgT25TZXRDb2RlYCBjb25maWd1cmF0aW9uLCB0aGlzIGZ1bmN0aW9uIG1heSBkaXJlY3RseSBhcHBseREBdGhlIG5ldyBgY29kZWAgaW4gdGhlIHNhbWUgYmxvY2sgb3IgYXR0ZW1wdCB0byBzY2hlZHVsZSB0aGUgdXBncmFkZS4AYEFsbCBvcmlnaW5zIGFyZSBhbGxvd2VkLgQNAUNvbnRhaW5zIGEgdmFyaWFudCBwZXIgZGlzcGF0Y2hhYmxlIGV4dHJpbnNpYyB0aGF0IHRoaXMgcGFsbGV0IGhhcy69AQAAAsEBAMEBAAAECDg4AMUBAAACOADJAQwwZnJhbWVfc3lzdGVtGGxpbWl0czBCbG9ja1dlaWdodHMAAAwBKGJhc2VfYmxvY2ssARhXZWlnaHQAASRtYXhfYmxvY2ssARhXZWlnaHQAASRwZXJfY2xhc3PNAQGEUGVyRGlzcGF0Y2hDbGFzczxXZWlnaHRzUGVyQ2xhc3M+AADNAQw0ZnJhbWVfc3VwcG9ydCBkaXNwYXRjaEBQZXJEaXNwYXRjaENsYXNzBARUAdEBAAwBGG5vcm1hbNEBAQRUAAEsb3BlcmF0aW9uYWzRAQEEVAABJG1hbmRhdG9yedEBAQRUAADRAQwwZnJhbWVfc3lzdGVtGGxpbWl0czxXZWlnaHRzUGVyQ2xhc3MAABABOGJhc2VfZXh0cmluc2ljLAEYV2VpZ2h0AAE0bWF4X2V4dHJpbnNpY50BAThPcHRpb248V2VpZ2h0PgABJG1heF90b3RhbJ0BAThPcHRpb248V2VpZ2h0PgABIHJlc2VydmVknQEBOE9wdGlvbjxXZWlnaHQ+AADVAQwwZnJhbWVfc3lzdGVtGGxpbWl0cyxCbG9ja0xlbmd0aAAABAEMbWF42QEBVFBlckRpc3BhdGNoQ2xhc3M8dTMyPgAA2QEMNGZyYW1lX3N1cHBvcnQgZGlzcGF0Y2hAUGVyRGlzcGF0Y2hDbGFzcwQEVAEQAAwBGG5vcm1hbBABBFQAASxvcGVyYXRpb25hbBABBFQAASRtYW5kYXRvcnkQAQRUAADdAQgoc3Bfd2VpZ2h0czxSdW50aW1lRGJXZWlnaHQAAAgBEHJlYWQYAQx1NjQAARR3cml0ZRgBDHU2NAAA4QEIKHNwX3ZlcnNpb244UnVudGltZVZlcnNpb24AACABJHNwZWNfbmFtZT0BAURDb3c8J3N0YXRpYywgc3RyPgABJGltcGxfbmFtZT0BAURDb3c8J3N0YXRpYywgc3RyPgABRGF1dGhvcmluZ192ZXJzaW9uEAEMdTMyAAEwc3BlY192ZXJzaW9uEAEMdTMyAAEwaW1wbF92ZXJzaW9uEAEMdTMyAAEQYXBpc+UBARxBcGlzVmVjAAFMdHJhbnNhY3Rpb25fdmVyc2lvbhABDHUzMgABOHN5c3RlbV92ZXJzaW9uCAEIdTgAAOUBBAxDb3cEBFQB6QEABADpAQAAAOkBAAAC7QEA7QEAAAQI8QEQAPEBAAADCAAAAAgA9QEMMGZyYW1lX3N5c3RlbRhwYWxsZXQURXJyb3IEBFQAASQ8SW52YWxpZFNwZWNOYW1lAAAIEQFUaGUgbmFtZSBvZiBzcGVjaWZpY2F0aW9uIGRvZXMgbm90IG1hdGNoIGJldHdlZW4gdGhlIGN1cnJlbnQgcnVudGltZVBhbmQgdGhlIG5ldyBydW50aW1lLmhTcGVjVmVyc2lvbk5lZWRzVG9JbmNyZWFzZQABCEEBVGhlIHNwZWNpZmljYXRpb24gdmVyc2lvbiBpcyBub3QgYWxsb3dlZCB0byBkZWNyZWFzZSBiZXR3ZWVuIHRoZSBjdXJyZW50IHJ1bnRpbWVQYW5kIHRoZSBuZXcgcnVudGltZS50RmFpbGVkVG9FeHRyYWN0UnVudGltZVZlcnNpb24AAgzsRmFpbGVkIHRvIGV4dHJhY3QgdGhlIHJ1bnRpbWUgdmVyc2lvbiBmcm9tIHRoZSBuZXcgcnVudGltZS4ACQFFaXRoZXIgY2FsbGluZyBgQ29yZV92ZXJzaW9uYCBvciBkZWNvZGluZyBgUnVudGltZVZlcnNpb25gIGZhaWxlZC5MTm9uRGVmYXVsdENvbXBvc2l0ZQADBPxTdWljaWRlIGNhbGxlZCB3aGVuIHRoZSBhY2NvdW50IGhhcyBub24tZGVmYXVsdCBjb21wb3NpdGUgZGF0YS48Tm9uWmVyb1JlZkNvdW50AAQENQFUaGVyZSBpcyBhIG5vbi16ZXJvIHJlZmVyZW5jZSBjb3VudCBwcmV2ZW50aW5nIHRoZSBhY2NvdW50IGZyb20gYmVpbmcgcHVyZ2VkLjBDYWxsRmlsdGVyZWQABQTQVGhlIG9yaWdpbiBmaWx0ZXIgcHJldmVudCB0aGUgY2FsbCB0byBiZSBkaXNwYXRjaGVkLmxNdWx0aUJsb2NrTWlncmF0aW9uc09uZ29pbmcABgRVAUEgbXVsdGktYmxvY2sgbWlncmF0aW9uIGlzIG9uZ29pbmcgYW5kIHByZXZlbnRzIHRoZSBjdXJyZW50IGNvZGUgZnJvbSBiZWluZyByZXBsYWNlZC5ETm90aGluZ0F1dGhvcml6ZWQABwRYTm8gdXBncmFkZSBhdXRob3JpemVkLjBVbmF1dGhvcml6ZWQACASUVGhlIHN1Ym1pdHRlZCBjb2RlIGlzIG5vdCBhdXRob3JpemVkLgRsRXJyb3IgZm9yIHRoZSBTeXN0ZW0gcGFsbGV0+QEIWG5vZGVfc3VidGVuc29yX3J1bnRpbWUsUnVudGltZUNhbGwAAVwYU3lzdGVtBAC5AQGtAXNlbGY6OnNwX2FwaV9oaWRkZW5faW5jbHVkZXNfY29uc3RydWN0X3J1bnRpbWU6OmhpZGRlbl9pbmNsdWRlOjpkaXNwYXRjaAo6OkNhbGxhYmxlQ2FsbEZvcjxTeXN0ZW0sIFJ1bnRpbWU+AAAAJFRpbWVzdGFtcAQA/QEBuQFzZWxmOjpzcF9hcGlfaGlkZGVuX2luY2x1ZGVzX2NvbnN0cnVjdF9ydW50aW1lOjpoaWRkZW5faW5jbHVkZTo6ZGlzcGF0Y2gKOjpDYWxsYWJsZUNhbGxGb3I8VGltZXN0YW1wLCBSdW50aW1lPgACABxHcmFuZHBhBAABAgGxAXNlbGY6OnNwX2FwaV9oaWRkZW5faW5jbHVkZXNfY29uc3RydWN0X3J1bnRpbWU6OmhpZGRlbl9pbmNsdWRlOjpkaXNwYXRjaAo6OkNhbGxhYmxlQ2FsbEZvcjxHcmFuZHBhLCBSdW50aW1lPgAEACBCYWxhbmNlcwQAMQIBtQFzZWxmOjpzcF9hcGlfaGlkZGVuX2luY2x1ZGVzX2NvbnN0cnVjdF9ydW50aW1lOjpoaWRkZW5faW5jbHVkZTo6ZGlzcGF0Y2gKOjpDYWxsYWJsZUNhbGxGb3I8QmFsYW5jZXMsIFJ1bnRpbWU+AAUAPFN1YnRlbnNvck1vZHVsZQQARQIB0QFzZWxmOjpzcF9hcGlfaGl

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

1dWl2b2NhdGlvbiBwcm9vZiBhbmQgdmFsaWRhdGUgdGhlIGdpdmVuIGtleSBvd25lcnNoaXAgcHJvb2b4YWdhaW5zdCB0aGUgZXh0cmFjdGVkIG9mZmVuZGVyLiBJZiBib3RoIGFyZSB2YWxpZCwgdGhlIG9mZmVuY2VEd2lsbCBiZSByZXBvcnRlZC5wcmVwb3J0X2VxdWl2b2NhdGlvbl91bnNpZ25lZAgBSGVxdWl2b2NhdGlvbl9wcm9vZgUCAchCb3g8RXF1aXZvY2F0aW9uUHJvb2Y8VDo6SGFzaCwgQmxvY2tOdW1iZXJGb3I8VD4+PgABPGtleV9vd25lcl9wcm9vZi0CAUBUOjpLZXlPd25lclByb29mAAEkCQFSZXBvcnQgdm90ZXIgZXF1aXZvY2F0aW9uL21pc2JlaGF2aW9yLiBUaGlzIG1ldGhvZCB3aWxsIHZlcmlmeSB0aGX0ZXF1aXZvY2F0aW9uIHByb29mIGFuZCB2YWxpZGF0ZSB0aGUgZ2l2ZW4ga2V5IG93bmVyc2hpcCBwcm9vZvhhZ2FpbnN0IHRoZSBleHRyYWN0ZWQgb2ZmZW5kZXIuIElmIGJvdGggYXJlIHZhbGlkLCB0aGUgb2ZmZW5jZUR3aWxsIGJlIHJlcG9ydGVkLgANAVRoaXMgZXh0cmluc2ljIG11c3QgYmUgY2FsbGVkIHVuc2lnbmVkIGFuZCBpdCBpcyBleHBlY3RlZCB0aGF0IG9ubHkVAWJsb2NrIGF1dGhvcnMgd2lsbCBjYWxsIGl0ICh2YWxpZGF0ZWQgaW4gYFZhbGlkYXRlVW5zaWduZWRgKSwgYXMgc3VjaBUBaWYgdGhlIGJsb2NrIGF1dGhvciBpcyBkZWZpbmVkIGl0IHdpbGwgYmUgZGVmaW5lZCBhcyB0aGUgZXF1aXZvY2F0aW9uJHJlcG9ydGVyLjBub3RlX3N0YWxsZWQIARRkZWxheRABREJsb2NrTnVtYmVyRm9yPFQ+AAFsYmVzdF9maW5hbGl6ZWRfYmxvY2tfbnVtYmVyEAFEQmxvY2tOdW1iZXJGb3I8VD4AAjA9AU5vdGUgdGhhdCB0aGUgY3VycmVudCBhdXRob3JpdHkgc2V0IG9mIHRoZSBHUkFORFBBIGZpbmFsaXR5IGdhZGdldCBoYXMgc3RhbGxlZC4AYQFUaGlzIHdpbGwgdHJpZ2dlciBhIGZvcmNlZCBhdXRob3JpdHkgc2V0IGNoYW5nZSBhdCB0aGUgYmVnaW5uaW5nIG9mIHRoZSBuZXh0IHNlc3Npb24sIHRvYQFiZSBlbmFjdGVkIGBkZWxheWAgYmxvY2tzIGFmdGVyIHRoYXQuIFRoZSBgZGVsYXlgIHNob3VsZCBiZSBoaWdoIGVub3VnaCB0byBzYWZlbHkgYXNzdW1lSQF0aGF0IHRoZSBibG9jayBzaWduYWxsaW5nIHRoZSBmb3JjZWQgY2hhbmdlIHdpbGwgbm90IGJlIHJlLW9yZ2VkIGUuZy4gMTAwMCBibG9ja3MuXQFUaGUgYmxvY2sgcHJvZHVjdGlvbiByYXRlICh3aGljaCBtYXkgYmUgc2xvd2VkIGRvd24gYmVjYXVzZSBvZiBmaW5hbGl0eSBsYWdnaW5nKSBzaG91bGRRAWJlIHRha2VuIGludG8gYWNjb3VudCB3aGVuIGNob29zaW5nIHRoZSBgZGVsYXlgLiBUaGUgR1JBTkRQQSB2b3RlcnMgYmFzZWQgb24gdGhlIG5ld1UBYXV0aG9yaXR5IHdpbGwgc3RhcnQgdm90aW5nIG9uIHRvcCBvZiBgYmVzdF9maW5hbGl6ZWRfYmxvY2tfbnVtYmVyYCBmb3IgbmV3IGZpbmFsaXplZE0BYmxvY2tz

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

1hdCBpZiB0aGUgc3VtIG9mIGFsbEUBZWxlbWVudHMgaXMgbGFyZ2VyIG9yIHNtYWxsZXIgdGhhbiB0aGUgYW1vdW50IG9mIGVsZW1lbnRzICogdTE2X21heCwgYWxsIGVsZW1lbnRzlHdpbGwgYmUgY29ycmVjdGVkIGZvciB0aGlzIGRldmlhdGlvbi4AHCMgQXJnczrAKiBgb3JpZ2luYDogKDxUIGFzIGZyYW1lX3N5c3RlbTo6Q29uZmlnPk9yaWdpbik67CAgICAtIFRoZSBjYWxsZXIsIGEgaG90a2V5IHdobyB3aXNoZXMgdG8gc2V0IHRoZWlyIHdlaWdodHMuAEQqIGBuZXR1aWRgICh1MTYpOswJLSBUaGUgbmV0d29yayB1aWQgd2UgYXJlIHNldHRpbmcgdGhlc2Ugd2VpZ2h0cyBvbi4AVCogYGRlc3RzYCAoVmVjPHUxNj4pOtQJLSBUaGUgZWRnZSBlbmRwb2ludCBmb3IgdGhlIHdlaWdodCwgaS5lLiBqIGZvciB3X2lqLgBcKiAnd2VpZ2h0cycgKFZlYzx1MTY+KTrsCS0gVGhlIHUxNiBpbnRlZ2VyIGVuY29kZWQgd2VpZ2h0cy4gSW50ZXJwcmV0ZWQgYXMgcmF0aW9uYWzoICAgIHZhbHVlcyBpbiB0aGUgcmFuZ2UgWzAsMV0uIFRoZXkgbXVzdCBzdW0gdG8gaW4zMjo6TUFYLgBgKiAndmVyc2lvbl9rZXknICggdTY0ICk6DQEJLSBUaGUgbmV0d29yayB2ZXJzaW9uIGtleSB0byBjaGVjayBpZiB0aGUgdmFsaWRhdG9yIGlzIHVwIHRvIGRhdGUuACAjIEV2ZW50OjQqIFdlaWdodHNTZXQ7wAktIE9uIHN1Y2Nlc3NmdWxseSBzZXR0aW5nIHRoZSB3ZWlnaHRzIG9uIGNoYWluLgAkIyBSYWlzZXM6aCogJ01lY2hhbmlzbURvZXNOb3RFeGlzdCc63AktIEF0dGVtcHRpbmcgdG8gc2V0IHdlaWdodHMgb24gYSBub24tZXhpc3RlbnQgbmV0d29yay4ASCogJ05vdFJlZ2lzdGVyZWQnOuwJLSBBdHRlbXB0aW5nIHRvIHNldCB3ZWlnaHRzIGZyb20gYSBub24gcmVnaXN0ZXJlZCBhY2NvdW50LgBoKiAnV2VpZ2h0VmVjTm90RXF1YWxTaXplJzroCS0gQXR0ZW1wdGluZyB0byBzZXQgd2VpZ2h0cyB3aXRoIHVpZHMgbm90IG9mIHNhbWUgbGVuZ3RoLgBIKiAnRHVwbGljYXRlVWlkcyc6xAktIEF0dGVtcHRpbmcgdG8gc2V0IHdlaWdodHMgd2l0aCBkdXBsaWNhdGUgdWlkcy4AlCAgICAqICdVaWRzTGVuZ3RoRXhjZWVkVWlkc0luU3ViTmV0JzrgCS0gQXR0ZW1wdGluZyB0byBzZXQgd2VpZ2h0cyBhYm92ZSB0aGUgbWF4IGFsbG93ZWQgdWlkcy4AcCogJ1VpZFZlY0NvbnRhaW5JbnZhbGlkT25lJzq8CS0gQXR0ZW1wdGluZyB0byBzZXQgd2VpZ2h0cyB3aXRoIGludmFsaWQgdWlkcy4AZCogJ1dlaWdodFZlY0xlbmd0aElzTG93JzrkCS0gQXR0ZW1wdGluZyB0byBzZXQgd2VpZ2h0cyB3aXRoIGZld2VyIHdlaWdodHMgdGhhbiBtaW4uAFgqICdNYXhXZWlnaHRFeGNlZWRlZCc68AktIEF0dGVtcHRpbmcgdG8gc2V0IHdlaWdodHMgd2l0aCBtYXggdmFsdWUgZXhjZWVkaW5nIGxpbWl0LlRzZXRfbWVjaGFuaXNtX3dlaWdodHMUARhuZXR1aWSgARhOZXRVaWQAARRtZWNpZAgBGE1lY2hJZAABFGRlc3RzSQIBIFZlYzx1MTY+AAEcd2VpZ2h0c0kCASBWZWM8dTE2PgABLHZlcnNpb25fa2V5GAEMdTY0AHf0QQEtLS0gU2V0cyB0aGUgY2FsbGVyIHdlaWdodHMgZm9yIHRoZSBpbmNlbnRpdmUgbWVjaGFuaXNtIGZvciBtZWNoYW5pc21zLiBUaGUgY2FsbE0BY2FuIGJlIG1hZGUgZnJvbSB0aGUgaG90a2V5IGFjY291bnQgc28gaXMgcG90ZW50aWFsbHkgaW5zZWN1cmUsIGhvd2V2ZXIsIHRoZSBkYW1hZ2U5AW9mIGNoYW5naW5nIHdlaWdodHMgaXMgbWluaW1hbCBpZiBjYXVnaHQgZWFybHkuIFRoaXMgZnVuY3Rpb24gaW5jbHVkZXMgYWxsIHRoZU0BY2hlY2tzIHRoYXQgdGhlIHBhc3NlZCB3ZWlnaHRzIG1lZXQgdGhlIHJlcXVpcmVtZW50cy4gU3RvcmVkIGFzIHUxNnMgdGhleSByZXByZXNlbnQtAXJhdGlvbmFsIHZhbHVlcyBpbiB0aGUgcmFuZ2UgWzAsMV0gd2hpY2ggc3VtIHRvIDEgYW5kIGNhbiBiZSBpbnRlcnByZXRlZCBhczkBcHJvYmFiaWxpdGllcy4gVGhlIHNwZWNpZmljIHdlaWdodHMgZGV0ZXJtaW5lIGhvdyBpbmZsYXRpb24gcHJvcGFnYXRlcyBvdXR3YXJkPGZyb20gdGhpcyBwZWVyLgAZAU5vdGU6IFRoZSAxNiBiaXQgaW50ZWdlcnMgd2VpZ2h0cyBzaG91bGQgcmVwcmVzZW50IDEuMCBhcyB0aGUgbWF4IHUxNi6JAUhvd2V2ZXIsIHRoZSBmdW5jdGlvbiBub3JtYWxpemVzIGFsbCBpbnRlZ2VycyB0byB1MTZfbWF4IGFueXdheS4gVGhpcyBtZWFucyB0aGF0IGlmIHRoZSBzdW0gb2YgYWxsRQFlbGVtZW50cyBpcyBsYXJnZXIgb3Igc21hbGxlciB0aGFuIHRoZSBhbW91bnQgb2YgZWxlbWVudHMgKiB1MTZfbWF4LCBhbGwgZWxlbWVudHOUd2lsbCBiZSBjb3JyZWN0ZWQgZm9yIHRoaXMgZGV2aWF0aW9uLgAcIyBBcmdzOsAqIGBvcmlnaW5gOiAoPFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+T3JpZ2luKTrsICAgIC0gVGhlIGNhbGxlciwgYSBob3RrZXkgd2hvIHdpc2hlcyB0byBzZXQgdGhlaXIgd2VpZ2h0cy4ARCogYG5ldHVpZGAgKHUxNik6zAktIFRoZSBuZXR3b3JrIHVpZCB3ZSBhcmUgc2V0dGluZyB0aGVzZSB3ZWlnaHRzIG9uLgBEKiBgbWVjaWRgIChgdThgKTp8ICAtIFRoZSB1OCBtZWNobmlzbSBpZGVudGlmaWVyLgBUKiBgZGVzdHNgIChWZWM8dTE2Pik61AktIFRoZSBlZGdlIGVuZHBvaW50IGZvciB0aGUgd2VpZ2h0LCBpLmUuIGogZm9yIHdfaWouAFwqICd3ZWlnaHRzJyAoVmVjPHUxNj4pOuwJLSBUaGUgdTE2IGludGVnZXIgZW5jb2RlZCB3ZWlnaHRzLiBJbnRlcnByZXRlZCBhcyByYXRpb25hbOggICAgdmFsdWVzIGluIHRoZSByYW5nZSBbMCwxXS4gVGhleSBtdXN0IHN1bSB0byBpbjMyOjpNQVguAGAqICd2ZXJzaW9uX2tleScgKCB1NjQgKToNAQktIFRoZSBuZXR3b3JrIHZlcnNpb24ga2V5IHRvIGNoZWNrIGlmIHRoZSB2YWxpZGF0b3IgaXMgdXAgdG8gZGF0ZS4AICMgRXZlbnQ6NCogV2VpZ2h0c1NldDvACS0gT24gc3VjY2Vzc2Z1bGx5IHNldHRpbmcgdGhlIHdlaWdodHMgb24gY2hhaW4uACQjIFJhaXNlczpoKiAnTWVjaGFuaXNtRG9lc05vdEV4aXN0JzrcCS0gQXR0ZW1wdGluZyB0byBzZXQgd2VpZ2h0cyBvbiBhIG5vbi1leGlzdGVudCBuZXR3b3JrLgBIKiAnTm90UmVnaXN0ZXJlZCc67AktIEF0dGVtcHRpbmcgdG8gc2V0IHdlaWdodHMgZnJvbSBhIG5vbiByZWdpc3RlcmVkIGFjY291bnQuAGgqICdXZWlnaHRWZWNOb3RFcXVhbFNpemUnOugJLSBBdHRlbXB0aW5nIHRvIHNldCB3ZWlnaHRzIHdpdGggdWlkcyBub3Qgb2Ygc2FtZSBsZW5ndGguAEgqICdEdXBsaWNhdGVVaWRzJzrECS0gQXR0ZW1wdGluZyB0byBzZXQgd2VpZ2h0cyB3aXRoIGR1cGxpY2F0ZSB1aWRzLgCUICAgICogJ1VpZHNMZW5ndGhFeGNlZWRVaWRzSW5TdWJOZXQnOuAJLSBBdHRlbXB0aW5nIHRvIHNldCB3ZWlnaHRzIGFib3ZlI

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

1Z2luYCAtIFRoZSBvcmlnaW4gb2YgdGhlIHRyYW5zYWN0aW9uLCB3aGljaCBtdXN0IGJlIHNpZ25lZCBieSB0aGUgY29sZGtleSB0aGF0IG93bnMgdGhlIGBob3RrZXlgLtQqIGBob3RrZXlgIC0gVGhlIGhvdGtleSB3aG9zZSBzdGFrZSBpcyBiZWluZyBzd2FwcGVkLhkBKiBgb3JpZ2luX25ldHVpZGAgLSBUaGUgbmV0d29yay9zdWJuZXQgSUQgZnJvbSB3aGljaCBzdGFrZSBpcyByZW1vdmVkLh0BKiBgZGVzdGluYXRpb25fbmV0dWlkYCAtIFRoZSBuZXR3b3JrL3N1Ym5ldCBJRCB0byB3aGljaCBzdGFrZSBpcyBhZGRlZC68KiBgYWxwaGFfYW1vdW50YCAtIFRoZSBhbW91bnQgb2Ygc3Rha2UgdG8gc3dhcC4pASogYGxpbWl0X3ByaWNlYCAtIFRoZSBsaW1pdCBwcmljZSBleHByZXNzZWQgaW4gdW5pdHMgb2YgUkFPIHBlciBvbmUgQWxwaGEu1QEqIGBhbGxvd19wYXJ0aWFsYCAtIEFsbG93cyBwYXJ0aWFsIGV4ZWN1dGlvbiBvZiB0aGUgYW1vdW50LiBJZiBzZXQgdG8gZmFsc2UsIHRoaXMgYmVjb21lcyBmaWxsIG9yIGtpbGwgdHlwZSBvciBvcmRlci4AICMgRXJyb3JzUFJldHVybnMgYW4gZXJyb3IgaWY6bQEqIFRoZSB0cmFuc2FjdGlvbiBpcyBub3Qgc2lnbmVkIGJ5IHRoZSBjb3JyZWN0IGNvbGRrZXkgKGkuZS4sIGBjb2xka2V5X293bnNfaG90a2V5YCBmYWlscykuAQEqIEVpdGhlciBgb3JpZ2luX25ldHVpZGAgb3IgYGRlc3RpbmF0aW9uX25ldHVpZGAgZG9lcyBub3QgZXhpc3QucCogVGhlIGhvdGtleSBkb2VzIG5vdCBleGlzdC4RASogVGhlcmUgaXMgaW5zdWZmaWNpZW50IHN0YWtlIG9uIGAoY29sZGtleSwgaG90a2V5LCBvcmlnaW5fbmV0dWlkKWAu5CogVGhlIHN3YXAgYW1vdW50IGlzIGJlbG93IHRoZSBtaW5pbXVtIHN0YWtlIHJlcXVpcmVtZW50LgAgIyBFdmVudHOsTWF5IGVtaXQgYSBgU3Rha2VTd2FwcGVkYCBldmVudCBvbiBzdWNjZXNzLlB0cnlfYXNzb2NpYXRlX2hvdGtleQQBGGhvdGtleQABMFQ6OkFjY291bnRJZABbILhBdHRlbXB0cyB0byBhc3NvY2lhdGUgYSBob3RrZXkgd2l0aCBhIGNvbGRrZXkuACwjIEFyZ3VtZW50c50BKiBgb3Jp

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

1hpLmUuYQFiZWNhdXNlIHlvdSBleHBlY3QgYHByb3h5YCB0byBoYXZlIGJlZW4gdXNlZCBwcmlvciBpbiB0aGUgY2FsbCBzdGFjayBhbmQgeW91IGRvIG5vdCB3YW50UQF0aGUgY2FsbCByZXN0cmljdGlvbnMgdG8gYXBwbHkgdG8gYW55IHN1Yi1hY2NvdW50cyksIHRoZW4gdXNlIGBhc19tdWx0aV90aHJlc2hvbGRfMWB8aW4gdGhlIE11bHRpc2lnIHBhbGxldCBpbnN0ZWFkLgD0Tk9URTogUHJpb3IgdG8gdmVyc2lvbiAqMTIsIHRoaXMgd2FzIGNhbGxlZCBgYXNfbGltaXRlZF9zdWJgLgDMVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIG11c3QgYmUgX1NpZ25lZF8uJGJhdGNoX2FsbAQBFGNhbGxzhQIBfFZlYzw8VCBhcyBDb25maWc+OjpSdW50aW1lQ2FsbD4AAjTsU2VuZCBhIGJhdGNoIG9mIGRpc3BhdGNoIGNhbGxzIGFuZCBhdG9taWNhbGx5IGV4ZWN1dGUgdGhlbS4hAVRoZSB3aG9sZSB0cmFuc2FjdGlvbiB3aWxsIHJvbGxiYWNrIGFuZCBmYWlsIGlmIGFueSBvZiB0aGUgY2FsbHMgZmFpbGVkLgCwTWF5IGJlIGNhbGxlZCBmcm9tIGFueSBvcmlnaW4gZXhjZXB0IGBOb25lYC4AXQEtIGBjYWxsc2A6IFRoZSBjYWxscyB0byBiZSBkaXNwYXRjaGVkIGZyb20gdGhlIHNhbWUgb3JpZ2luLiBUaGUgbnVtYmVyIG9mIGNhbGwgbXVzdCBub3Q5ASAgZXhjZWVkIHRoZSBjb25zdGFudDogYGJhdGNoZWRfY2FsbHNfbGltaXRgIChhdmFpbGFibGUgaW4gY29uc3RhbnQgbWV0YWRhdGEpLgBVAUlmIG9yaWdpbiBpcyByb290IHRoZW4gdGhlIGNhbGxzIGFyZSBkaXNwYXRjaGVkIHdpdGhvdXQgY2hlY2tpbmcgb3JpZ2luIGZpbHRlci4gKFRoaXPsaW5jbHVkZXMgYnlwYXNzaW5nIGBmcmFtZV9zeXN0ZW06OkNvbmZpZzo6QmFzZUNhbGxGaWx0ZXJgKS4ANCMjIENvbXBsZXhpdHnQLSBPKEMpIHdoZXJlIEMgaXMgdGhlIG51bWJlciBvZiBjYWxscyB0byBiZSBiYXRjaGVkLixkaXNwYXRjaF9hcwgBJGFzX29yaWdpbokCAVRCb3g8VDo6UGFsbGV0c09yaWdpbj4AARBjYWxs+QEBfEJveDw8VCBhcyBDb25maWc+OjpSdW50aW1lQ2FsbD4AAxjIRGlzcGF0Y2hlcyBhIGZ1bmN0aW9uIGNhbGwgd2l0aCBhIHByb3ZpZGVkIG9yaWdpbi4AxFRoZSBkaXNwYXRjaCBvcmlnaW4gZm9yIHRoaXMgY2FsbCBtdXN0IGJlIF9Sb290Xy4ANCMjIENvbXBsZXhpdHkcLSBPKDEpLixmb3JjZV9iYXRjaAQBFGNhbGxzhQIBfFZlYzw8VCBhcyBDb25maWc+OjpSdW50aW1lQ2FsbD4ABDR8U2VuZCBhIGJhdGNoIG9mIGRpc3BhdGNoIGNhbGxzLtRVbmxpa2UgYGJhdGNoYCwgaXQgYWxsb3dzIGVycm9ycyBhbmQgd29uJ3QgaW50ZXJydXB0LgCwTWF5IGJlIGNhbGxlZCBmcm9tIGFueSBvcmlnaW4gZXhjZXB0IGBOb25lYC4AXQEtIGBjYWxsc2A6IFRoZSBjYWxscyB0byBiZSBkaXNwYXRjaGVkIGZyb20gdGhlIHNhbWUgb3JpZ2luLiBUaGUgbnVtYmVyIG9mIGNhbGwgbXVzdCBub3Q5ASAgZXhjZWVkIHRoZSBjb25zdGFudDogYGJhdGNoZWRfY2FsbHNfbGltaXRgIChhdmFpbGFibGUgaW4gY29uc3RhbnQgbWV0YWRhdGEpLgBNAUlmIG9yaWdpbiBpcyByb290IHRoZW4gdGhlIGNhbGxzIGFyZSBkaXNwYXRjaCB3aXRob3V0IGNoZWNraW5nIG9yaWdpbiBmaWx0ZXIuIChUaGlz7GluY2x1ZGVzIGJ5cGFzc2luZyBgZnJhbWVfc3lzdGVtOjpDb25maWc6OkJhc2VDYWxsRmlsdGVyYCkuADQjIyBDb21wbGV4aXR50C0gTyhDKSB3aGVyZSBDIGlzIHRoZSBudW1iZXIgb2YgY2FsbHMgdG8gYmUgYmF0Y2hlZC4sd2l0aF93ZWlnaHQIARBjYWxs+QEBfEJveDw8VCBhcyBDb25maWc+OjpSdW50aW1lQ2FsbD4AARh3ZWlnaHQsARhXZWlnaHQABRjERGlzcGF0Y2ggYSBmdW5jdGlvbiBjYWxsIHdpdGggYSBzcGVjaWZpZWQgd2VpZ2h0LgAtAVRoaXMgZnVuY3Rpb24gZG9lcyBub3QgY2hlY2sgdGhlIHdlaWdodCBvZiB0aGUgY2FsbCwgYW5kIGluc3RlYWQgYWxsb3dzIHRoZbhSb290IG9yaWdpbiB0byBzcGVjaWZ5IHRoZSB3ZWlnaHQgb2YgdGhlIGNhbGwuAMRUaGUgZGlzcGF0Y2ggb3JpZ2luIGZvciB0aGlzIGNhbGwgbXVzdCBiZSBfUm9vdF8uHGlmX2Vsc2UIARBtYWlu+QEBfEJveDw8VCBhcyBDb25maWc+OjpSdW50aW1lQ2FsbD4AASBmYWxsYmFja/kBAXxCb3g8PFQgYXMgQ29uZmlnPjo6UnVudGltZUNhbGw+AAZcFQFEaXNwYXRjaCBhIGZhbGxiYWNrIGNhbGwgaW4gdGhlIGV2ZW50IHRoZSBtYWluIGNhbGwgZmFpbHMgdG8gZXhlY3V0ZS6wTWF5IGJlIGNhbGxlZCBmcm9tIGFueSBvcmlnaW4gZXhjZXB0IGBOb25lYC4A5FRoaXMgZnVuY3Rpb24gZmlyc3QgYXR0ZW1wdHMgdG8gZGlzcGF0Y2ggdGhlIGBtYWluYCBjYWxsLtRJZiB0aGUgYG1haW5gIGNhbGwgZmFpbHMsIHRoZSBgZmFsbGJhY2tgIGlzIGF0dGVtdGVkLhUBaWYgdGhlIGZhbGxiYWNrIGlzIHN1Y2Nlc3NmdWxseSBkaXNwYXRjaGVkLCB0aGUgd2VpZ2h0cyBvZiBib3RoIGNhbGxzJQFhcmUgYWNjdW11bGF0ZWQgYW5kIGFuIGV2ZW50IGNvbnRhaW5pbmcgdGhlIG1haW4gY2FsbCBlcnJvciBpcyBkZXBvc2l0ZWQuANxJbiB0aGUgZXZlbnQgb2YgYSBmYWxsYmFjayBmYWlsdXJlIHRoZSB3aG9sZSBjYWxsIGZhaWxzaHdpdGggdGhlIHdlaWdodHMgcmV0dXJuZWQuAEEBLSBgbWFpbmA6IFR

1oZSBtYWluIGNhbGwgdG8gYmUgZGlzcGF0Y2hlZC4gVGhpcyBpcyB0aGUgcHJpbWFyeSBhY3Rpb24gdG8gZXhlY3V0ZS49AS0gYGZhbGxiYWNrYDogVGhlIGZhbGxiYWNrIGNhbGwgdG8gYmUgZGlzcGF0Y2hlZCBpbiBjYXNlIHRoZSBgbWFpbmAgY2FsbCBmYWlscy4ARCMjIERpc3BhdGNoIExvZ2ljQQEtIElmIHRoZSBvcmlnaW4gaXMgYHJvb3RgLCBib3RoIHRoZSBtYWluIGFuZCBmYWxsYmFjayBjYWxscyBhcmUgZXhlY3V0ZWQgd2l0aG91dHggIGFwcGx5aW5nIGFueSBvcmlnaW4gZmlsdGVycy5JAS0gSWYgdGhlIG9yaWdpbiBpcyBub3QgYHJvb3RgLCB0aGUgb3JpZ2luIGZpbHRlciBpcyBhcHBsaWVkIHRvIGJvdGggdGhlIGBtYWluYCBhbmRMICBgZmFsbGJhY2tgIGNhbGxzLgAsIyMgVXNlIENhc2VZAS0gU29tZSB1c2UgY2FzZXMgbWlnaHQgaW52b2x2ZSBzdWJtaXR0aW5nIGEgYGJhdGNoYCB0eXBlIGNhbGwgaW4gZWl0aGVyIG1haW4sIGZhbGxiYWNrKCAgb3IgYm90aC5QZGlzcGF0Y2hfYXNfZmFsbGlibGUIASRhc19vcmlnaW6JAgFUQm94PFQ6OlBhbGxldHNPcmlnaW4+AAEQY2FsbPkBAXxCb3g8PFQgYXMgQ29uZmlnPjo6UnVudGltZUNhbGw+AAcUyERpc3BhdGNoZXMgYSBmdW5jdGlvbiBjYWxsIHdpdGggYSBwcm92aWRlZCBvcmlnaW4uAFEBQWxtb3N0IHRoZSBzYW1lIGFzIFtgUGFsbGV0OjpkaXNwYXRjaF9hc2BdIGJ1dCBmb3J3YXJkcyBhbnkgZXJyb3Igb2YgdGhlIGlubmVyIGNhbGwuAMRUaGUgZGlzcGF0Y2ggb3JpZ2luIGZvciB0aGlzIGNhbGwgbXVzdCBiZSBfUm9vdF8uBA0BQ29udGFpbnMgYSB2YXJpYW50IHBlciBkaXNwYXRjaGFibGUgZXh0cmluc2ljIHRoYXQgdGhpcyBwYWxsZXQgaGFzLoUCAAAC+QEAiQIIWG5vZGVfc3VidGVuc29yX3J1bnRpbWUwT3JpZ2luQ2FsbGVyAAEIGHN5c3RlbQQAjQIBdGZyYW1lX3N5c3RlbTo6T3JpZ2luPFJ1bnRpbWU+AAAAIEV0aGVyZXVtBACRAgFccGFsbGV0X2V0aGVyZXVtOjpPcmlnaW4AFQAAjQIMNGZyYW1lX3N1cHBvcnQgZGlzcGF0Y2gkUmF3T3JpZ2luBCRBY2NvdW50SWQBAAEQEFJvb3QAAAAYU2lnbmVkBAAAASRBY2NvdW50SWQAAQAQTm9uZQACAChBdXRob3JpemVkAAMAAJECCDxwYWxsZXRfZXRoZXJldW0kUmF3T3JpZ2luAAEETEV0aGVyZXVtVHJhbnNhY3Rpb24EAMQBEEgxNjAAAAAAlQIMLHBhbGxldF9zdWRvGHBhbGxldBBDYWxsBARUAAEUEHN1ZG8EARBjYWxs+QEBfEJveDw8VCBhcyBDb25maWc+OjpSdW50aW1lQ2FsbD4AAAQ1AUF1dGhlbnRpY2F0ZXMgdGhlIHN1ZG8ga2V5IGFuZCBkaXNwYXRjaGVzIGEgZnVuY3Rpb24gY2FsbCB3aXRoIGBSb290YCBvcmlnaW4uVHN1ZG9fdW5jaGVja2VkX3dlaWdodAgBEGNhbGz5AQF8Qm94PDxUIGFzIENvbmZpZz46OlJ1bnRpbWVDYWxsPgABGHdlaWdodCwBGFdlaWdodAABFDUBQXV0aGVudGljYXRlcyB0aGUgc3VkbyBrZXkgYW5kIGRpc3BhdGNoZXMgYSBmdW5jdGlvbiBjYWxsIHdpdGggYFJvb3RgIG9yaWdpbi4tAVRoaXMgZnVuY3Rpb24gZG9lcyBub3QgY2hlY2sgdGhlIHdlaWdodCBvZiB0aGUgY2FsbCwgYW5kIGluc3RlYWQgYWxsb3dzIHRoZbBTdWRvIHVzZXIgdG8gc3BlY2lmeSB0aGUgd2VpZ2h0IG9mIHRoZSBjYWxsLgDMVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIG11c3QgYmUgX1NpZ25lZF8uHHNldF9rZXkEAQxuZXc1AgFQQWNjb3VudElkTG9va3VwT2Y8VD4AAghdAUF1dGhlbnRpY2F0ZXMgdGhlIGN1cnJlbnQgc3VkbyBrZXkgYW5kIHNldHMgdGhlIGdpdmVuIEFjY291bnRJZCAoYG5ld2ApIGFzIHRoZSBuZXcgc3VkbxBrZXkuHHN1ZG9fYXMIAQx3aG81AgFQQWNjb3VudElkTG9va3VwT2Y8VD4AARBjYWxs+QEBfEJveDw8VCBhcyBDb25maWc+OjpSdW50aW1lQ2FsbD4AAxBNAUF1dGhlbnRpY2F0ZXMgdGhlIHN1ZG8ga2V5IGFuZCBkaXNwYXRjaGVzIGEgZnVuY3Rpb24gY2FsbCB3aXRoIGBTaWduZWRgIG9yaWdpbiBmcm9tQGEgZ2l2ZW4gYWNjb3VudC4AzFRoZSBkaXNwYXRjaCBvcmlnaW4gZm9yIHRoaXMgY2FsbCBtdXN0IGJlIF9TaWduZWRfLihyZW1vdmVfa2V5AAQMhFBlcm1hbmVudGx5IHJlbW92ZXMgdGhlIHN1ZG8ga2V5LgBsKipUaGlzIGNhbm5vdCBiZSB1bi1kb25lLioqBA0BQ29udGFpbnMgYSB2YXJpYW50IHBlciBkaXNwYXRjaGFibGUgZXh0cmluc2ljIHRoYXQgdGhpcyBwYWxsZXQgaGFzLpkCDDxwYWxsZXRfbXVsdGlzaWcYcGFsbGV0EENhbGwEBFQAARRQYXNfbXVsdGlfdGhyZXNob2xkXzEIAURvdGhlcl9zaWduYXRvcmllcz0CAURWZWM8VDo6QWNjb3VudElkPgABEGNhbGz5AQF8Qm94PDxUIGFzIENvbmZpZz46OlJ1bnRpbWVDYWxsPgAAMFEBSW1tZWRpYXRlbHkgZGlzcGF0Y2ggYSBtdWx0aS1zaWduYXR1cmUgY2FsbCB1c2luZyBhIHNpbmdsZSBhcHByb3ZhbCBmcm9tIHRoZSBjYWxsZXIuAMxUaGUgZGlzcGF0Y2ggb3JpZ2luIGZvciB0aGlzIGNhbGwgbXVzdCBiZSBfU2lnbmVkXy4APQEtIGBvdGhlcl9zaWduYXRvcmllc2A6IFRoZSBhY2NvdW50cyAob3RoZXIgdGhhbiB0aGUgc2VuZGVyKSB3aG8gYXJlIHBhcnQgb2YgdGhlAQFtdWx0aS1zaWduYXR1cmUsIGJ1dCBkbyBub3QgcGFydGljaXBhdGUgaW4gdGhlIGFwcHJvdmFsIHByb2Nlc3MuiC0gYGNhbGxgOiBUaGUgY2FsbCB0byBiZSBleGVjdXRlZC4AuFJlc3VsdCBpcyBlcXVpdmFsZW50IHRvIHRoZSBkaXNwYXRjaGVkIHJlc3VsdC4ANCMjIENvbXBsZXhpdHkZAU8oWiArIEMpIHdoZXJlIFogaXMgdGhlIGxlbmd0aCBvZiB0aGUgY2FsbCBhbmQgQyBpdHMgZXhlY3V0aW9uIHdlaWdodC4gYXNfbXVsdGkUASR0aHJlc2hvbGSgAQx1MTYAAURvdGhlcl9zaWduYXRvcmllcz0CAURWZWM8VDo6QWNjb3VudElkPgABPG1heWJlX3RpbWVwb2ludJ0CAZBPcHRpb248VGltZXBvaW50PEJsb2NrTnVtYmVyRm9yPFQ+Pj4AARBjYWxs+QEBfEJveDw8VCBhcyBDb25maWc+OjpSdW50aW1lQ2FsbD4AAShtYXhfd2VpZ2h0LAEYV2VpZ2h0AAGcVQFSZWdpc3RlciBhcHByb3ZhbCBmb3IgYSBkaXNwYXRjaCB0byBiZSBtYWRlIGZyb20gYSBkZXRlcm1pbmlzdGljIGNvbXBvc2l0ZSBhY2NvdW50IGlm+GFwcHJvdmVkIGJ5IGEgdG90YWwgb2YgYHRocmVzaG9sZCAtIDFgIG9mIGBvdGhlcl9zaWduYXRvcmllc2AuALBJZiB0aGVyZSBhcmUgZW5vdWdoLCB0aGVuIGRpc3BhdGNoIHRoZSBjYWxsLgAtAVBheW1lbnQ6IGBEZXBvc2l0QmFzZWAgd2lsbCBiZSByZXNlcnZlZCBpZiB0aGlzIGlzIHRoZSBmaXJzdCBhcHByb3ZhbCwgcGx1cz0BYHRocmVzaG9sZGAgdGltZXMgYERlcG9zaXRGYWN0b3JgLiBJdCBpcyByZXR1cm5lZCBvbmNlIHRoaXMgZGlzcGF0Y2ggaGFwcGVucyBvcjRpcyBjYW5jZWxsZWQuAMxUaGUgZGlzcGF0Y2ggb3JpZ2luIGZvciB0aGlzIGNhbGwgbXVzdCBiZSBfU2lnbmVkXy4AVQEtIGB0aHJlc2hvbGRgOiBUaGUgdG90YWwgbnVtYmVyIG9mIGFwcHJvdmFscyBmb3IgdGhpcyBkaXNwYXRjaCBiZWZvcmUgaXQgaXMgZXhlY3V0ZWQuQQEtIGBvdGhlcl9zaWduYXRvcmllc2A6IFRoZSBhY2NvdW50cyAob3RoZXIgdGhhbiB0aGUgc2VuZGVyKSB3aG8gY2FuIGFwcHJvdmUgdGhpc2xkaXNwYXRjaC4gTWF5IG5vdCBiZSBlbXB0eS5ZAS0gYG1heWJlX3RpbWVwb2ludGA6IElmIHRoaXMgaXMgdGhlIGZpcnN0IGFwcHJvdmFsLCB0aGVuIHRoaXMgbXVzdCBiZSBgTm9uZWAuIElmIGl0IGlzUQFub3QgdGhlIGZpcnN0IGFwcHJvdmFsLCB0aGVuIGl0IG11c3QgYmUgYFNvbWVgLCB3aXRoIHRoZSB0aW1lcG9pbnQgKGJsb2NrIG51bWJlciBhbmTUdHJhbnNhY3Rpb24gaW5kZXgpIG9mIHRoZSBmaXJzdCBhcHByb3ZhbCB0cmFuc2FjdGlvbi6ILSBgY2FsbGA6IFRoZSBjYWxsIHRvIGJlIGV4ZWN1dGVkLgAdAU5PVEU6IFVubGVzcyB0aGlzIGlzIHRoZSBmaW5hbCBhcHByb3ZhbCwgeW91IHdpbGwgZ2VuZXJhbGx5IHdhbnQgdG8gdXNlGQFgYXBwcm92ZV9hc19tdWx0aWAgaW5zdGVhZCwgc2luY2UgaXQgb25seSByZXF1aXJlcyBhIGhhc2ggb2YgdGhlIGNhbGwuAFkBUmVzdWx0IGlzIGVxdWl2YWxlbnQgdG8gdGhlIGRpc3BhdGNoZWQgcmVzdWx0IGlmIGB0aHJlc2hvbGRgIGlzIGV4YWN0bHkgYDFgLiBPdGhlcndpc2VVAW9uIHN1Y2Nlc3MsIHJlc3VsdCBpcyBgT2tgIGFuZCB0aGUgcmVzdWx0IGZyb20gdGhlIGludGVyaW9yIGNhbGwsIGlmIGl0IHdhcyBleGVjdXRlZCzcbWF5IGJlIGZvdW5kIGluIHRoZSBkZXBvc2l0ZWQgYE11bHRpc2lnRXhlY3V0ZWRgIGV2ZW50LgA0IyMgQ29tcGxleGl0eVAtIGBPKFMgKyBaICsgQ2FsbClgLswtIFVwIHRvIG9uZSBiYWxhbmNlLXJlc2VydmUgb3IgdW5yZXNlcnZlIG9wZXJhdGlvbi49AS0gT25lIHBhc3N0aHJvdWdoIG9wZXJhdGlvbiwgb25lIGluc2VydCwgYm90aCBgTyhTKWAgd2hlcmUgYFNgIGlzIHRoZSBudW1iZXIgb2ZFASAgc2lnbmF0b3JpZXMuIGBTYCBpcyBjYXBwZWQgYnkgYE1heFNpZ25hdG9yaWVzYCwgd2l0aCB3ZWlnaHQgYmVpbmcgcHJvcG9ydGlvbmFsLiEBLSBPbmUgY2FsbCBlbmNvZGUgJiBoYXNoLCBib3RoIG9mIGNvbXBsZXhpdHkgYE8oWilgIHdoZXJlIGBaYCBpcyB0eC1sZW4uvC0gT25lIGVuY29kZSAmIGhhc2gsIGJvdGggb2YgY29tcGxleGl0eSBgTyhTKWAu1C0gVXAgdG8gb25lIGJpbmFyeSBzZWFyY2ggYW5kIGluc2VydCAoYE8obG9nUyArIFMpYCku+C0gSS9POiAxIHJlYWQgYE8oUylgLCB1cCB0byAxIG11dGF0ZSBgTyhTKWAuIFVwIHRvIG9uZSByZW1vdmUuMC0gT25lIGV2ZW50LmwtIFRoZSB3ZWlnaHQgb2YgdGhlIGBjYWxsYC5NAS0gU3RvcmFnZTogaW5zZXJ0cyBvbmUgaXRlbSwgdmFsdWUgc2l6ZSBib3VuZGVkIGJ5IGBNYXhTaWduYXRvcmllc2AsIHdpdGggYSBkZXBvc2l0GQEgIHRha2VuIGZvciBpdHMgbGlmZXRpbWUgb2YgYERlcG9zaXRCYXNlICsgdGhyZXNob2xkICogRGVwb3NpdEZhY3RvcmAuQGFwcHJvdmVfYXNfbXVsdGkUASR0aHJlc2hvbGSgAQx1MTYAAURvdGhlcl9zaWduYXRvcmllcz0CAURWZWM8VDo6QWNjb3VudElkPgABPG1heWJlX3RpbWVwb2ludJ0CAZBPcHRpb248VGltZXBvaW50PEJsb2NrTnVtYmVyRm9yPFQ+Pj4AASRjYWxsX2hhc2gEASBbdTg7IDMyXQABKG1heF93ZWlnaHQsARhXZWlnaHQAAnhVAVJlZ2lzdGVyIGFwcHJvdmFsIGZvciBhIGRpc3BhdGNoIHRvIGJlIG1hZGUgZnJvbSBhIGRldGVybWluaXN0aWMgY29tcG9zaXRlIGFjY291bnQgaWb4YXBwcm92ZWQgYnkgYSB0b3RhbCBvZiBgdGhyZXNob2xkIC0gMWAgb2YgYG90aGVyX3NpZ25hdG9yaWVzYC4ALQFQYXltZW50OiBgRGVwb3NpdEJhc2VgIHdpbGwgYmUgcmVzZXJ2ZWQgaWYgdGhpcyBpcyB0aGUgZmlyc3QgYXBwcm92YWwsIHBsdXM9AWB0aHJlc2hvbGRgIHRpbWVzIGBEZXBvc2l0RmFjdG9yYC4gSXQgaXMgcmV0dXJuZWQgb25jZSB0aGlzIGRpc3BhdGNoIGhhcHBlbnMgb3I0aXMgY2FuY2VsbGVkLgDMVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIG11c3QgYmUgX1NpZ25lZF8uAFUBLSBgdGhyZXNob2xkYDogVGhlIHRvdGFsIG51bWJlciBvZiBhcHByb3ZhbHMgZm9yIHRoaXMgZGlzcGF0Y2ggYmVmb3JlIGl0IGlzIGV4ZWN1dGVkLkEBLSBgb3RoZXJfc2lnbmF0b3JpZXNgOiBUaGUgYWNjb3VudHMgKG90aGVyIHRoYW4gdGhlIHNlbmRlcikgd2hvIGNhbiBhcHByb3ZlIHRoaXNsZGlzcGF0Y2guIE1heSBub3QgYmUgZW1wdHkuWQEtIGBtYXliZV90aW1lcG9pbnRgOiBJZiB0aGlzIGlzIHRoZSBmaXJzdCBhcHByb3ZhbCwgdGhlbiB0aGlzIG11c3QgYmUgYE5vbmVgLiBJZiBpdCBpc1EBbm90IHRoZSBmaXJzdCBhcHByb3ZhbCwgdGhlbiBpdCBtdXN0IGJlIGBTb21lYCwgd2l0aCB0aGUgdGltZXBvaW50IChibG9jayBudW1iZXIgYW5k1HRyYW5zYWN0aW9uIGluZGV4KSBvZiB0aGUgZmlyc3QgYXBwcm92YWwgdHJhbnNhY3Rpb24uzC0gYGNhbGxfaGFzaGA6IFR

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

1dlaWdodCBtZXRlcmluZyBhbmRRAWFnZW5kYSBzcGFjZSwgc2FtZSBhcyBhIHJlZ3VsYXIgdGFzay4gSWYgYSBwZXJpb2RpYyB0YXNrIGZhaWxzLCBpdCB3aWxsIGJlIHNjaGVkdWxlZJBub3JtYWxseSB3aGlsZSB0aGUgdGFzayBpcyByZXRyeWluZy4AUQFUYXNrcyBzY2hlZHVsZWQgYXMgYSByZXN1bHQgb2YgYSByZXRyeSBmb3IgYSBwZXJpb2RpYyB0YXNrIGFyZSB1bm5hbWVkLCBub24tcGVyaW9kaWM9AWNsb25lcyBvZiB0aGUgb3JpZ2luYWwgdGFzay4gVGhlaXIgcmV0cnkgY29uZmlndXJhdGlvbiB3aWxsIGJlIGRlcml2ZWQgZnJvbSB0aGVNAW9yaWdpbmFsIHRhc2sncyBjb25maWd1cmF0aW9uLCBidXQgd2lsbCBoYXZlIGEgbG93ZXIgdmFsdWUgZm9yIGByZW1haW5pbmdgIHRoYW4gdGhlZG9yaWdpbmFsIGB0b3RhbF9yZXRyaWVzYC4wY2FuY2VsX3JldHJ5BAEQdGFza/wBeFRhc2tBZGRyZXNzPEJsb2NrTnVtYmVyRm9yPFQ+PgAIBKhSZW1vdmVzIHRoZSByZXRyeSBjb25maWd1cmF0aW9uIG9mIGEgdGFzay5IY2FuY2VsX3JldHJ5X25hbWVkBAEIaWQEASBUYXNrTmFtZQAJBLxDYW5jZWwgdGhlIHJldHJ5IGNvbmZpZ3VyYXRpb24gb2YgYSBuYW1lZCB0YXNrLgQNAUNvbnRhaW5zIGEgdmFyaWFudCBwZXIgZGlzcGF0Y2hhYmxlIGV4dHJpbnNpYyB0aGF0IHRoaXMgcGFsbGV0IGhhcy6pAgQYT3B0aW9uBARUAfwBCBBOb25lAAAAEFNvbWUEAPwAAAEAAK0CDFhwYWxsZXRfc3VidGVuc29yX3Byb3h5GHBhbGxldBBDYWxsBARUAAEsFHByb3h5DAEQcmVhbDUCAVBBY2NvdW50SWRMb29rdXBPZjxUPgABQGZvcmNlX3Byb3h5X3R5cGWxAgFQT3B0aW9uPFQ6OlByb3h5VHlwZT4AARBjYWxs+QEBfEJveDw8VCBhcyBDb25maWc+OjpSdW50aW1lQ2FsbD4AACRNAURpc3BhdGNoIHRoZSBnaXZlbiBgY2FsbGAgZnJvbSBhbiBhY2NvdW50IHRoYXQgdGhlIHNlbmRlciBpcyBhdXRob3Jpc2VkIGZvciB0aHJvdWdoMGBhZGRfcHJveHlgLgDMVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIG11c3QgYmUgX1NpZ25lZF8uACxQYXJhbWV0ZXJzOg0BLSBgcmVhbGA6IFRoZSBhY2NvdW50IHRoYXQgdGhlIHByb3h5IHdpbGwgbWFrZSBhIGNhbGwgb24gYmVoYWxmIG9mLmEBLSBgZm9yY2VfcHJveHlfdHlwZWA6IFNwZWNpZnkgdGhlIGV4YWN0IHByb3h5IHR5cGUgdG8gYmUgdXNlZCBhbmQgY2hlY2tlZCBmb3IgdGhpcyBjYWxsLtAtIGBjYWxsYDogVGhlIGNhbGwgdG8gYmUgbWFkZSBieSB0aGUgYHJlYWxgIGFjY291bnQuJGFkZF9wcm94eQwBIGRlbGVnYXRlNQIBUEFjY291bnRJZExvb2t1cE9mPFQ+AAEocHJveHlfdHlwZQkBATBUOjpQcm94eVR5cGUAARRkZWxheRABREJsb2NrTnVtYmVyRm9yPFQ+AAEkRQFSZWdpc3RlciBhIHByb3h5IGFjY291bnQgZm9yIHRoZSBzZW5kZXIgdGhhdCBpcyBhYmxlIHRvIG1ha2UgY2FsbHMgb24gaXRzIGJlaGFsZi4AzFRoZSBkaXNwYXRjaCBvcmlnaW4gZm9yIHRoaXMgY2FsbCBtdXN0IGJlIF9TaWduZWRfLgAsUGFyYW1ldGVyczoRAS0gYHByb3h5YDogVGhlIGFjY291bnQgdGhhdCB0aGUgYGNhbGxlcmAgd291bGQgbGlrZSB0byBtYWtlIGEgcHJveHku/C0gYHByb3h5X3R5cGVgOiBUaGUgcGVybWlzc2lvbnMgYWxsb3dlZCBmb3IgdGhpcyBwcm94eSBhY2NvdW50Lk0BLSBgZGVsYXlgOiBUaGUgYW5ub3VuY2VtZW50IHBlcmlvZCByZXF1aXJlZCBvZiB0aGUgaW5pdGlhbCBwcm94eS4gV2lsbCBnZW5lcmFsbHkgYmUUemVyby4wcmVtb3ZlX3Byb3h5DAEgZGVsZWdhdGU1AgFQQWNjb3VudElkTG9va3VwT2Y8VD4AAShwcm94eV90eXBlCQEBMFQ6OlByb3h5VHlwZQABFGRlbGF5EAFEQmxvY2tOdW1iZXJGb3I8VD4AAhyoVW5yZWdpc3RlciBhIHByb3h5IGFjY291bnQgZm9yIHRoZSBzZW5kZXIuAMxUaGUgZGlzcGF0Y2ggb3JpZ2luIGZvciB0aGlzIGNhbGwgbXVzdCBiZSBfU2lnbmVkXy4ALFBhcmFtZXRlcnM6JQEtIGBwcm94eWA6IFRoZSBhY2NvdW50IHRoYXQgdGhlIGBjYWxsZXJgIHdvdWxkIGxpa2UgdG8gcmVtb3ZlIGFzIGEgcHJveHkuQQEtIGBwcm94eV90eXBlYDogVGhlIHBlcm1pc3Npb25zIGN1cnJlbnRseSBlbmFibGVkIGZvciB0aGUgcmVtb3ZlZCBwcm94eSBhY2NvdW50LjhyZW1vdmVfcHJveGllcwADGLRVbnJlZ2lzdGVyIGFsbCBwcm94eSBhY2NvdW50cyBmb3IgdGhlIHNlbmRlci4AzFRoZSBkaXNwYXRjaCBvcmlnaW4gZm9yIHRoaXMgY2FsbCBtdXN0IGJlIF9TaWduZWRfLgBdAVdBUk5JTkc6IFRoaXMgbWF5IGJlIGNhbGxlZCBvbiBhY2NvdW50cyBjcmVhdGVkIGJ5IGBjcmVhdGVfcHVyZWAsIGhvd2V2ZXIgaWYgZG9uZSwgdGhlblkBdGhlIHVucmVzZXJ2ZWQgZmVlcyB3aWxsIGJlIGluYWNjZXNzaWJsZS4gKipBbGwgYWNjZXNzIHRvIHRoaXMgYWNjb3VudCB3aWxsIGJlIGxvc3QuKiosY3JlYXRlX3B1cmUMAShwcm94eV90eXBlCQEBMFQ6OlByb3h5VHlwZQABFGRlbGF5EAFEQmxvY2tOdW1iZXJGb3I8VD4AARRpbmRleKABDHUxNgAESDkBU3Bhd24gYSBmcmVzaCBuZXcgYWNjb3VudCB0aGF0IGlzIGd1YXJhbnRlZWQgdG8gYmUgb3RoZXJ3aXNlIGluYWNjZXNzaWJsZSwgYW5k/GluaXRpYWxpemUgaXQgd2l0aCBhIHByb3h5IG9mIGBwcm94eV90eXBlYCBmb3IgYG9yaWdpbmAgc2VuZGVyLgBsUmVxdWlyZXMgYSBgU2lnbmVkYCBvcmlnaW4uAFEBLSBgcHJveHlfdHlwZWA6IFRoZSB0eXBlIG9mIHRoZSBwcm94eSB0aGF0IHRoZSBzZW5kZXIgd2lsbCBiZSByZWdpc3RlcmVkIGFzIG92ZXIgdGhlTQFuZXcgYWNjb3VudC4gVGhpcyB3aWxsIGFsbW9zdCBhbHdheXMgYmUgdGhlIG1vc3QgcGVybWlzc2l2ZSBgUHJveHlUeXBlYCBwb3NzaWJsZSB0b3hhbGxvdyBmb3IgbWF4aW11bSBmbGV4aWJpbGl0eS5RAS0gYGluZGV4YDogQSBkaXNhbWJpZ3VhdGlvbiBpbmRleCwgaW4gY2FzZSB0aGlzIGlzIGNhbGxlZCBtdWx0aXBsZSB0aW1lcyBpbiB0aGUgc2FtZV0BdHJhbnNhY3Rpb24gKGUuZy4gd2l0aCBgdXRpbGl0eTo6YmF0Y2hgKS4gVW5sZXNzIHlvdSdyZSB1c2luZyBgYmF0Y2hgIHlvdSBwcm9iYWJseSBqdXN0QHdhbnQgdG8gdXNlIGAwYC5NAS0gYGRlbGF5YDogVGhlIGFubm91bmNlbWVudCBwZXJpb2QgcmVxdWlyZWQgb2YgdGhlIGluaXRpYWwgcHJveHkuIFdpbGwgZ2VuZXJhbGx5IGJlFHplcm8uAFEBRmFpbHMgd2l0aCBgRHVwbGljYXRlYCBpZiB0aGlzIGhhcyBhbHJlYWR5IGJlZW4gY2FsbGVkIGluIHRoaXMgdHJhbnNhY3Rpb24sIGZyb20gdGhlmHNhbWUgc2VuZGVyLCB3aXRoIHRoZSBzYW1lIHBhcmFtZXRlcnMuAORGYWlscyBpZiB0aGVyZSBhcmUgaW5zdWZmaWNpZW50IGZ1bmRzIHRvIHBheSBmb3IgZGVwb3NpdC4ka2lsbF9wdXJlFAEcc3Bhd25lcjUCAVBBY2NvdW50SWRMb29rdXBPZjxUPgABKHByb3h5X3R5cGUJAQEwVDo6UHJveHlUeXBlAAEUaW5kZXigAQx1MTYAARhoZWlnaHSxAQFEQmxvY2tOdW1iZXJGb3I8VD4AASRleHRfaW5kZXixAQEMdTMyAAVAoFJlbW92ZXMgYSBwcmV2aW91c2x5IHNwYXduZWQgcHVyZSBwcm94eS4ASQFXQVJOSU5HOiAqKkFsbCBhY2Nlc3MgdG8gdGhpcyBhY2NvdW50IHdpbGwgYmUgbG9zdC4qKiBBbnkgZnVuZHMgaGVsZCBpbiBpdCB3aWxsIGJlNGluYWNjZXNzaWJsZS4AWQFSZXF1aXJlcyBhIGBTaWduZWRgIG9yaWdpbiwgYW5kIHR

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

1FRoZSBleHRyaW5zaWMgc2V0cyB0aGUgbmV3IGF1dGhvcml0aWVzIGZvciBBdXJhIGNvbnNlbnN1cy6gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50LgkBVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIEF1cmEgcGFsbGV0IHRvIGNoYW5nZSB0aGUgYXV0aG9yaXRpZXMuVHN1ZG9fc2V0X2RlZmF1bHRfdGFrZQQBMGRlZmF1bHRfdGFrZaABDHUxNgABDNBUaGUgZXh0cmluc2ljIHNldHMgdGhlIGRlZmF1bHQgdGFrZSBmb3IgdGhlIG5ldHdvcmsuoEl0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudC4VAVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgZGVmYXVsdCB0YWtlLlhzdWRvX3NldF90eF9yYXRlX2xpbWl0BAE0dHhfcmF0ZV9saW1pdBgBDHU2NAACDPhUaGUgZXh0cmluc2ljIHNldHMgdGhlIHRyYW5zYWN0aW9uIHJhdGUgbGltaXQgZm9yIHRoZSBuZXR3b3JrLqBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQuPQFUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIHRyYW5zYWN0aW9uIHJhdGUgbGltaXQubHN1ZG9fc2V0X3NlcnZpbmdfcmF0ZV9saW1pdAgBGG5ldHVpZKABGE5ldFVpZAABSHNlcnZpbmdfcmF0ZV9saW1pdBgBDHU2NAADDNxUaGUgZXh0cmluc2ljIHNldHMgdGhlIHNlcnZpbmcgcmF0ZSBsaW1pdCBmb3IgYSBzdWJuZXQu4El0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudCBvciBzdWJuZXQgb3duZXIuLQFUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIHNlcnZpbmcgcmF0ZSBsaW1pdC5cc3Vkb19zZXRfbWluX2RpZmZpY3VsdHkIARhuZXR1aWSgARhOZXRVaWQAAThtaW5fZGlmZmljdWx0eRgBDHU2NAAEDNxUaGUgZXh0cmluc2ljIHNldHMgdGhlIG1pbmltdW0gZGlmZmljdWx0eSBmb3IgYSBzdWJuZXQu4El0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlI

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

1HJvb3QgYWNjb3VudCBhbmQgc3VibmV0IG93bmVyLmkBVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBtYXhpbXVtIGFsbG93ZWQgVUlEcyBmb3IgYSBzdWJuZXQuOHN1ZG9fc2V0X2thcHBhCAEYbmV0dWlkoAEYTmV0VWlkAAEUa2FwcGGgAQx1MTYAEAyoVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBrYXBwYSBmb3IgYSBzdWJuZXQu4El0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudCBvciBzdWJuZXQgb3duZXIu+FRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUga2FwcGEuMHN1ZG9fc2V0X3JobwgBGG5ldHVpZKABGE5ldFVpZAABDHJob6ABDHUxNgARDKBUaGUgZXh0cmluc2ljIHNldHMgdGhlIHJobyBmb3IgYSBzdWJuZXQu4El0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudCBvciBzdWJuZXQgb3duZXIu8FRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgcmhvLmBzdWRvX3NldF9hY3Rpdml0eV9jdXRvZmYIARhuZXR1aWSgARhOZXRVaWQAATxhY3Rpdml0eV9jdXRvZmagAQx1MTYAEgzQVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBhY3Rpdml0eSBjdXRvZmYgZm9yIGEgc3VibmV0LuBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQgb3Igc3VibmV0IG93bmVyLiEBVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBhY3Rpdml0eSBjdXRvZmYulHN1ZG9fc2V0X25ldHdvcmtfcmVnaXN0cmF0aW9uX2FsbG93ZWQIARhuZXR1aWSgARhOZXRVaWQAAVByZWdpc3RyYXRpb25fYWxsb3dlZCQBEGJvb2wAEwwFAVRoZSBleHRyaW5zaWMgc2V0cyB0aGUgbmV0d29yayByZWdpc3RyYXRpb24gYWxsb3dlZCBmb3IgYSBzdWJuZXQu4El0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlI

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

1HJvb3QgYWNjb3VudC5NAVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgbWF4aW11bSBhbGxvd2VkIHZhbGlkYXRvcnMudHN1ZG9fc2V0X2JvbmRzX21vdmluZ19hdmVyYWdlCAEYbmV0dWlkoAEYTmV0VWlkAAFQYm9uZHNfbW92aW5nX2F2ZXJhZ2UYAQx1NjQAGgzkVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBib25kcyBtb3ZpbmcgYXZlcmFnZSBmb3IgYSBzdWJuZXQu4El0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudCBvciBzdWJuZXQgb3duZXIuNQFUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIGJvbmRzIG1vdmluZyBhdmVyYWdlLlhzdWRvX3NldF9ib25kc19wZW5hbHR5CAEYbmV0dWlkoAEYTmV0VWlkAAE0Ym9uZHNfcGVuYWx0eaABDHUxNgA8DMhUaGUgZXh0cmluc2ljIHNldHMgdGhlIGJvbmRzIHBlbmFsdHkgZm9yIGEgc3VibmV0LuBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQgb3Igc3VibmV0IG93bmVyLhkBVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBib25kcyBwZW5hbHR5LpBzdWRvX3NldF9tYXhfcmVnaXN0cmF0aW9uc19wZXJfYmxvY2sIARhuZXR1aWSgARhOZXRVaWQAAWxtYXhfcmVnaXN0cmF0aW9uc19wZXJfYmxvY2ugAQx1MTYAGwwRAVRoZSBleHRyaW5zaWMgc2V0cyB0aGUgbWF4aW11bSByZWdpc3RyYXRpb25zIHBlciBibG9jayBmb3IgYSBzdWJuZXQuoEl0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlI

1HJvb3QgYWNjb3VudC5hAVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgbWF4aW11bSByZWdpc3RyYXRpb25zIHBlciBibG9jay5kc3Vkb19zZXRfc3VibmV0X293bmVyX2N1dAQBQHN1Ym5ldF9vd25lcl9jdXSgAQx1MTYAHAzUVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBzdWJuZXQgb3duZXIgY3V0IGZvciBhIHN1Ym5ldC6gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50LiUBVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBzdWJuZXQgb3duZXIgY3V0LmxzdWRvX3NldF9uZXR3b3JrX3JhdGVfbGltaXQEAShyYXRlX2xpbWl0GAEMdTY0AB0M6FRoZSBleHRyaW5zaWMgc2V0cyB0aGUgbmV0d29yayByYXRlIGxpbWl0IGZvciB0aGUgbmV0d29yay6gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50Li0BVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBuZXR3b3JrIHJhdGUgbGltaXQuOHN1ZG9fc2V0X3RlbXBvCAEYbmV0dWlkoAEYTmV0VWlkAAEUdGVtcG+gAQx1MTYAHgyoVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSB0ZW1wbyBmb3IgYSBzdWJuZXQuoEl0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudC74VGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSB0ZW1wby5cc3Vkb19zZXRfdG90YWxfaXNzdWFuY2UEATh0b3RhbF9pc3N1YW5jZRgBLFRhb0N1cnJlbmN5ACEM2FRoZSBleHRyaW5zaWMgc2V0cyB0aGUgdG90YWwgaXNzdWFuY2UgZm9yIHRoZSBuZXR3b3JrLqBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQuRQFUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIGlzc3VhbmNlIGZvciB0aGUgbmV0d29yay6Ac3Vkb19zZXRfbmV0d29ya19pbW11bml0eV9wZXJpb2QEATxpbW11bml0eV9wZXJpb2QYAQx1NjQAIwzcVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBpbW11bml0eSBwZXJpb2QgZm9yIHRoZSBuZXR3b3JrLqBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQuYQFUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIGltbXVuaXR5IHBlcmlvZCBmb3IgdGhlIG5ldHdvcmsueHN1ZG9fc2V0X25ldHdvcmtfbWluX2xvY2tfY29zdAQBJGxvY2tfY29zdBgBLFRhb0N1cnJlbmN5ACQM1FRoZSBleHRyaW5zaWMgc2V0cyB0aGUgbWluIGxvY2sgY29zdCBmb3IgdGhlIG5ldHdvcmsuoEl0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlI

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

1oZSBvcmlnaW4gb2YgdGhlIGNhbGwsIHdoaWNoIG11c3QgYmUgdGhlIHJvb3QgYWNjb3VudCBvciBzdWJuZXQgb3duZXIuxC0gYG5ldHVpZGA6IFRoZSB1bmlxdWUgaWRlbnRpZmllciBmb3IgdGhlIHN1Ym5ldC49AS0gYHJlY3ljbGVfb3JfYnVybmA6IFRoZSBkZXNpcmVkIGJlaGF2aW91ciBvZiB0aGUgImJ1cm4iIFVJRChzKSBmb3IgdGhlIHN1Ym5ldC4AaHN1ZG9fdG9nZ2xlX2V2bV9wcmVjb21waWxlCAE0cHJlY29tcGlsZV9pZB0BAThQcmVjb21waWxlRW51bQABHGVuYWJsZWQkARBib29sAD4wsFRvZ2dsZXMgdGhlIGVuYWJsZW1lbnQgb2YgYW4gRVZNIHByZWNvbXBpbGUuACwjIEFyZ3VtZW50cxEBKiBgb3JpZ2luYCAtIFRoZSBvcmlnaW4gb2YgdGhlIGNhbGwsIHdoaWNoIG11c3QgYmUgdGhlIHJvb3QgYWNjb3VudC4NASogYHByZWNvbXBpbGVfaWRgIC0gVGhlIGlkZW50aWZpZXIgb2YgdGhlIEVWTSBwcmVjb21waWxlIHRvIHRvZ2dsZS7kKiBgZW5hYmxlZGAgLSBUaGUgbmV3IGVuYWJsZW1lbnQgc3RhdGUgb2YgdGhlIHByZWNvbXBpbGUuACAjIEVycm9yc9gqIGBCYWRPcmlnaW5gIC0gSWYgdGhlIGNhbGxlciBpcyBub3QgdGhlIHJvb3QgYWNjb3VudC4AICMgV2VpZ2h03FdlaWdodCBpcyBoYW5kbGVkIGJ5IHRoZSBgI1twYWxsZXQ6OndlaWdodF1gIGF0dHJpYnV0ZS5wc3Vkb19zZXRfc3VibmV0X21vdmluZ19hbHBoYQQBFGFscGhh7QQBGEk5NkYzMgA/LAAALCMgQXJndW1lbnRzEQEqIGBvcmlnaW5gIC0gVGhlIG9yaWdpbiBvZiB0aGUgY2FsbCwgd2hpY2ggbXVzdCBiZSB0aGUgcm9vdCBhY2NvdW50LgUBKiBgYWxwaGFgIC0gVGhlIG5ldyBtb3ZpbmcgYWxwaGEgdmFsdWUgZm9yIHRoZSBTdWJuZXRNb3ZpbmdBbHBoYS4AICMgRXJyb3Jz2CogYEJhZE9yaWdpbmAgLSBJZiB0aGUgY2FsbGVyIGlzIG5vdCB0aGUgcm9vdCBhY2NvdW50LgAgIyBXZWlnaHTcV2VpZ2h0IGlzIGhhbmRsZWQgYnkgdGhlIGAjW3BhbGxldDo6d2VpZ2h0XWAgYXR0cmlidXRlLnBzdWRvX3NldF9zdWJuZXRfb3duZXJfaG90a2V5CAEYbmV0dWlkoAEYTmV0VWlkAAEYaG90a2V5AAGYPFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+OjpBY2NvdW50SWQAQDDAQ2hhbmdlIHRoZSBTdWJuZXRPd25lckhvdGtleSBmb3IgYSBnaXZlbiBzdWJuZXQuACwjIEFyZ3VtZW50cxEBKiBgb3JpZ2luYCAtIFRoZSBvcmlnaW4gb2YgdGhlIGNhbGwsIHdoaWNoIG11c3QgYmUgdGhlIHN1Ym5ldCBvd25lci7IKiBgbmV0dWlkYCAtIFRoZSB1bmlxdWUgaWRlbnRpZmllciBmb3IgdGhlIHN1Ym5ldC7EKiBgaG90a2V5YCAtIFRoZSBuZXcgaG90a2V5IGZvciB0aGUgc3VibmV0IG93bmVyLgAgIyBFcnJvcnMZASogYEJhZE9yaWdpbmAgLSBJZiB0aGUgY2FsbGVyIGlzIG5vdCB0aGUgc3VibmV0IG93bmVyIG9yIHJvb3QgYWNjb3VudC4AICMgV2VpZ2h03FdlaWdodCBpcyBoYW5kbGVkIGJ5IHRoZSBgI1twYWxsZXQ6OndlaWdodF1gIGF0dHJpYnV0ZS6Ec3Vkb19zZXRfZW1hX3ByaWNlX2hhbHZpbmdfcGVyaW9kCAEYbmV0dWlkoAEYTmV0VWlkAAEsZW1hX2hhbHZpbmcYAQx1NjQAQSwAACwjIEFyZ3VtZW50cxEBKiBgb3JpZ2luYCAtIFRoZSBvcmlnaW4gb2YgdGhlIGNhbGwsIHdoaWNoIG11c3QgYmUgdGhlIHJvb3QgYWNjb3VudC74KiBgZW1hX2FscGhhX3BlcmlvZGAgLSBOdW1iZXIgb2YgYmxvY2tzIGZvciBFTUEgcHJpY2UgdG8gaGFsdmUAICMgRXJyb3Jz2CogYEJhZE9yaWdpbmAgLSBJZiB0aGUgY2FsbGVyIGlzIG5vdCB0aGUgcm9vdCBhY2NvdW50LgAgIyBXZWlnaHTcV2VpZ2h0IGlzIGhhbmRsZWQgYnkgdGhlIGAjW3BhbGxldDo6d2VpZ2h0XWAgYXR0cmlidXRlLoBzdWRvX3NldF9hbHBoYV9zaWdtb2lkX3N0ZWVwbmVzcwgBGG5ldHVpZKABGE5ldFVpZAABJHN0ZWVwbmVzc6QBDGkxNgBEPAAALCMgQXJndW1lbnRzEQEqIGBvcmlnaW5gIC0gVGhlIG9yaWdpbiBvZiB0aGUgY2FsbCwgd2hpY2ggbXVzdCBiZSB0aGUgcm9vdCBhY2NvdW50LsgqIGBuZXR1aWRgIC0gVGhlIHVuaXF1ZSBpZGVudGlmaWVyIGZvciB0aGUgc3VibmV0LlUBKiBgc3RlZXBuZXNzYCAtIFRoZSBTdGVlcG5lc3MgZm9yIHRoZSBhbHBoYSBzaWdtb2lkIGZ1bmN0aW9uLiAocmFuZ2UgaXMgMC1pbnQxNjo6TUFYLLBuZWdhdGl2ZSB2YWx1ZXMgYXJlIHJlc2VydmVkIGZvciBmdXR1cmUgdXNlKQAgIyBFcnJvcnPYKiBgQmFkT3JpZ2luYCAtIElmIHRoZSBjYWxsZXIgaXMgbm90IHRoZSByb290IGFjY291bnQuAQEqIGBTdWJuZXREb2VzTm90RXhpc3RgIC0gSWYgdGhlIHNwZWNpZmllZCBzdWJuZXQgZG9lcyBub3QgZXhpc3QuNQEqIGBOZWdhdGl2ZVNpZ21vaWRTdGVlcG5lc3NgIC0gSWYgdGhlIHN0ZWVwbmVzcyBpcyBuZWdhdGl2ZSBhbmQgdGhlIGNhbGxlciBpcxRyb290LiAjIFdlaWdodNxXZWlnaHQgaXMgaGFuZGxlZCBieSB0aGUgYCNbcGFsbGV0Ojp3ZWlnaHRdYCBhdHRyaWJ1dGUuWHN1ZG9fc2V0X3l1bWEzX2VuYWJsZWQIARhuZXR1aWSgARhOZXRVaWQAARxlbmFibGVkJAEQYm9vbABFJLRFbmFibGVzIG9yIGRpc2FibGVzIFl1bWEzIGZvciBhIGdpdmVuIHN1Ym5ldC4AMCMgUGFyYW1ldGVyc00BLSBgb3JpZ2luYDogVGhlIG9yaWdpbiBvZiB0aGUgY2FsbCwgd2hpY2ggbXVzdCBiZSB0aGUgcm9vdCBhY2NvdW50IG9yIHN1Ym5ldCBvd25lci7ELSBgbmV0dWlkYDogVGhlIHVuaXF1ZSBpZGVudGlmaWVyIGZvciB0aGUgc3VibmV0LtwtIGBlbmFibGVkYDogQSBib29sZWFuIGZsYWcgdG8gZW5hYmxlIG9y

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

1kgAkTW9ydGFsMTQ3BAAIAACTACRNb3J0YWwxNDgEAAgAAJQAJE1vcnRhbDE0OQQACAAAlQAkTW9ydGFsMTUwBAAIAACWACRNb3J0YWwxNTEEAAgAAJcAJE1vcnRhbDE1MgQACAAAmAAkTW9ydGFsMTUzBAAIAACZACRNb3J0YWwxNTQEAAgAAJoAJE1vcnRhbDE1NQQACAAAmwAkTW9ydGFsMTU2BAAIAACcACRNb3J0YWwxNTcEAAgAAJ0AJE1vcnRhbDE1OAQACAAAngAkTW9ydGFsMTU5BAAIAACfACRNb3J0YWwxNjAEAAgAAKAAJE1vcnRhbDE2MQQACAAAoQAkTW9ydGFsMTYyBAAIAACiACRNb3J0YWwxNjMEAAgAAKMAJE1vcnRhbDE2NAQACAAApAAkTW9ydGFsMTY1BAAIAAClACRNb3J0YWwxNjYEAAgAAKYAJE1vcnRhbDE2NwQACAAApwAkTW9ydGFsMTY4BAAIAACoACRNb3J0YWwxNjkEAAgAAKkAJE1vcnRhbDE3MAQACAAAqgAkTW9ydGFsMTcxBAAIAACrACRNb3J0YWwxNzIEAAgAAKwAJE1vcnRhbDE3MwQACAAArQAkTW9ydGFsMTc0BAAIAACuACRNb3J0YWwxNzUEAAgAAK8AJE1vcnRhbDE3NgQACAAAsAAkTW9ydGFsMTc3BAAIAACxACRNb3J0YWwxNzgEAAgAALIAJE1vcnRhbDE3OQQACAAAswAkTW9ydGFsMTgwBAAIAAC0ACRNb3J0YWwxODEEAAgAALUAJE1vcnRhbDE4MgQACAAAtgAkTW9ydGFsMTgzBAAIAAC3ACRNb3J0YWwxODQEAAgAALgAJE1vcnRhbDE4NQQACAAAuQAkTW9ydGFsMTg2BAAIAAC6ACRNb3J0YWwxODcEAAgAALsAJE1vcnRhbDE4OAQACAAAvAAkTW9ydGFsMTg5BAAIAAC9ACRNb3J0YWwxOTAEAAgAAL4AJE1vcnRhbDE5MQQACAAAvwAkTW9ydGFsMTkyBAAIAADAACRNb3J0YWwxOTMEAAgAAMEAJE1vcnRhbDE5NAQACAAAwgAkTW9ydGFsMTk1BAAIAADDACRNb3J0YWwxOTYEAAgAAMQAJE1vcnRhbDE5NwQACAAAxQAkTW9ydGFsMTk4BAAIAADGACRNb3J0YWwxOTkEAAgAAMcAJE1vcnRhbDIwMAQACAAAyAAkTW9ydGFsMjAxBAAIAADJACRNb3J0YWwyMDIEAAgAAMoAJE1vcnRhbDIwMwQACAAAywAkTW9ydGFsMjA0BAAIAADMACRNb3J0YWwyMDUEAAgAAM0AJE1vcnRhbDIwNgQACAAAzgAkTW9ydGFsMjA3BAAIAADPACRNb3J0YWwyMDgEAAgAANAAJE1vcnRhbDIwOQQACAAA0QAkTW9ydGFsMjEwBAAIAADSACRNb3J0YWwyMTEEAAgAANMAJE1vcnRhbDIxMgQACAAA1AAkTW9ydGFsMjEzBAAIAADVACRNb3J0YWwyMTQEAAgAANYAJE1vcnRhbDIxNQQACAAA1wAkTW9ydGFsMjE2BAAIAADYACRNb3J0YWwyMTcEAAgAANkAJE1vcnRhbDIxOAQACAAA2gAkTW9ydGFsMjE5BAAIAADbACRNb3J0YWwyMjAEAAgAANwAJE1vcnRhbDIyMQQACAAA3QAkTW9ydGFsMjIyBAAIAADeACRNb3J0YWwyMjMEAAgAAN8AJE1vcnRhbDIyNAQACAAA4AAkTW9ydGFsMjI1BAAIAADhACRNb3J0YWwyMjYEAAgAAOIAJE1vcnRhbDIyNwQACAAA4wAkTW9ydGFsMjI4BAAIAADkACRNb3J0YWwyMjkEAAgAAOUAJE1vcnRhbDIzMAQACAAA5gAkTW9ydGFsMjMxBAAIAADnACRNb3J0YWwyMzIEAAgAAOgAJE1vcnRhbDIzMwQACAAA6QAkTW9ydGFsMjM0BAAIAADqACRNb3J0YWwyMzUEAAgAAOsAJE1vcnRhbDIzNgQACAAA7AAkTW9ydGFsMjM3BAAIAADtACRNb3J0YWwyMzgEAAgAAO4AJE1vcnRhbDIzOQQACAAA7wAkTW9ydGFsMjQwBAAIAADwACRNb3J0YWwyNDEEAAgAAPEAJE1vcnRhbDI0MgQACAAA8gAkTW9ydGFsMjQzBAAIAADzACRNb3J0YWwyNDQEAAgAAPQAJE1vcnRhbDI0NQQACAAA9QAkTW9ydGFsMjQ2BAAIAAD2ACRNb3J0YWwyNDcEAAgAAPcAJE1vcnRhbDI0OAQACAAA+AAkTW9ydGFsMjQ5BAAIAAD5ACRNb3J0YWwyNTAEAAgAAPoAJE1vcnRhbDI1MQQACAAA+wAkTW9ydGFsMjUyBAAIAAD8ACRNb3J0YWwyNTMEAAgAAP0AJE1vcnRhbDI1NAQACAAA/gAkTW9ydGFsMjU1BAAIAAD/AAAFBgxYbm9kZV9zdWJ0ZW5zb3JfcnVudGltZSxjaGVja19ub25jZShDaGVja05vbmNlBARUAAAEALEBASBUOjpOb25jZQAACQYQMGZyYW1lX3N5c3RlbShleHRlbnNpb25zMGNoZWNrX3dlaWdodCxDaGVja1dlaWdodAQEVAAAAAANBgxYbm9kZV9zdWJ0ZW5zb3JfcnVudGltZWx0cmFuc2FjdGlvbl9wYXltZW50X3dyYXBwZXJ8Q2hhcmdlVHJhbnNhY3Rpb25QYXltZW50V3JhcHBlcgQEVAAABAFoY2hhcmdlX3RyYW5zYWN0aW9uX3BheW1lbnQRBgFsQ2hhcmdlVHJhbnNhY3Rpb25QYXltZW50PFQ+AAARBghocGFsbGV0X3RyYW5zYWN0aW9uX3BheW1lbnRgQ2hhcmdlVHJhbnNhY3Rpb25QYXltZW50BARUAAAEADABMEJhbGFuY2VPZjxUPgAAFQYMWG5vZGVfc3VidGVuc29yX3J1bnRpbWUwc3Vkb193cmFwcGVyYFN1ZG9UcmFuc2FjdGlvbkV4dGVuc2lvbgQEVAGNAQAAABkGDEBwYWxsZXRfc3VidGVuc29yVHRyYW5zYWN0aW9uX2V4dGVuc2lvbnRTdWJ0ZW5zb3JUcmFuc2FjdGlvbkV4dGVuc2lvbgQEVAGNAQAAAB0GDDBwYWxsZXRfZHJhbmQ4ZHJhbmRfcHJpb3JpdHk0RHJhbmRQcmlvcml0eQQEVAGNAQAAACEGCHRmcmFtZV9tZXRhZGF0YV9oYXNoX2V4dGVuc2lvbkRDaGVja01ldGFkYXRhSGFzaAQEVAAABAEQbW9kZSUGARBNb2RlAAAlBgh0ZnJhbWVfbWV0YWRhdGFfaGFzaF9leHRlbnNpb24QTW9kZQABCCBEaXNhYmxlZAAAABxFbmFibGVkAAEAACkGEChzcF9ydW50aW1lHGdlbmVyaWNMdW5jaGVja2VkX2V4dHJpbnNpY0hVbmNoZWNrZWRFeHRyaW5zaWMQHEFkZHJlc3MBNQIQQ2FsbAH5ASRTaWduYXR1cmUBoQUURXh0cmEB6QUABAA4AAAALQYAAALlBQAxBgxMYm91bmRlZF9jb2xsZWN0aW9ucyxib3VuZGVkX3ZlYyhCb3VuZGVkVmVjCARUATQEUwAABAC4ARhWZWM8VD4AADUGCEhzcF9jb25zZW5zdXNfc2xvdHMQU2xvdAAABAAYAQx1NjQAADkGCDhwYWxsZXRfZ3JhbmRwYSxTdG9yZWRTdGF0ZQQETgEQARAQTGl2ZQAAADBQZW5kaW5nUGF1c2UIATBzY2hlZHVsZWRfYXQQAQROAAEUZGVsYXkQAQROAAEAGFBhdXNlZAACADRQZW5kaW5nUmVzdW1lCAEwc2NoZWR1bGVkX2F0EAEETgABFGRlbGF5EAEETgADAAA9Bgg4cGFsbGV0X2dyYW5kcGFMU3RvcmVkUGVuZGluZ0NoYW5nZQgETgEQFExpbWl0AAAQATBzY2hlZHVsZWRfYXQQAQROAAEUZGVsYXkQAQROAAFAbmV4dF9hdXRob3JpdGllc0EGAWxCb3VuZGVkQXV0aG9yaXR5TGlzdDxMaW1pdD4AARhmb3JjZWTMASRPcHRpb248Tj4AAEEGDExib3VuZGVkX2NvbGxlY3Rpb25zQHdlYWtfYm91bmRlZF92ZWM4V2Vha0JvdW5kZWRWZWMIBFQBiARTAAAEAIQBGFZlYzxUPgAARQYMOHBhbGxldF9ncmFuZHBhGHBhbGxldBRFcnJvcgQEVAABHCxQYXVzZUZhaWxlZAAACAUBQXR0ZW1wdCB0byBzaWduYWwgR1JBTkRQQSBwYXVzZSB3aGVuIHRoZSBhdXRob3JpdHkgc2V0IGlzbid0IGxpdmWkKGVpdGhlciBwYXVzZWQgb3IgYWxyZWFkeSBwZW5kaW5nIHBhdXNlKS4wUmVzdW1lRmFpbGVkAAEIEQFBdHRlbXB0IHRvIHNpZ25hbCBHUkFORFBBIHJlc3VtZSB3aGVuIHRoZSBhdXRob3JpdHkgc2V0IGlzbid0IHBhdXNlZKAo

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

1aW1pdEV4Y2VlZGVkAB4EOQFBbiBheG9uIG9yIHByb21ldGhldXMgc2VydmluZyBleGNlZWRlZCB0aGUgcmF0ZSBsaW1pdCBmb3IgYSByZWdpc3RlcmVkIG5ldXJvbi5wVWlkc0xlbmd0aEV4Y2VlZFVpZHNJblN1Yk5ldAAfBBEBVGhlIGNhbGxlciBpcyBhdHRlbXB0aW5nIHRvIHNldCB3ZWlnaHRzIHdpdGggbW9yZSBVSURzIHRoYW4gYWxsb3dlZC5oTmV0d29ya1R4UmF0ZUxpbWl0RXhjZWVkZWQAIAQFAUEgdHJhbnNhY3RvciBleGNlZWRlZCB0aGUgcmF0ZSBsaW1pdCBmb3IgYWRkIG5ldHdvcmsgdHJhbnNhY3Rpb24ubERlbGVnYXRlVHhSYXRlTGltaXRFeGNlZWRlZAAhBPhBIHRyYW5zYWN0b3IgZXhjZWVkZWQgdGhlIHJhdGUgbGltaXQgZm9yIGRlbGVnYXRlIHRyYW5zYWN0aW9uLnBIb3RLZXlTZXRUeFJhdGVMaW1pdEV4Y2VlZGVkACIEEQFBIHRyYW5zYWN0b3IgZXhjZWVkZWQgdGhlIHJhdGUgbGltaXQgZm9yIHNldHRpbmcgb3Igc3dhcHBpbmcgaG90a2V5LmBTdGFraW5nUmF0ZUxpbWl0RXhjZWVkZWQAIwTEQSB0cmFuc2FjdG9yIGV4Y2VlZGVkIHRoZSByYXRlIGxpbWl0IGZvciBzdGFraW5nLmhTdWJOZXRSZWdpc3RyYXRpb25EaXNhYmxlZAAkBGRSZWdpc3RyYXRpb24gaXMgZGlzYWJsZWQugFRvb01hbnlSZWdpc3RyYXRpb25zVGhpc0ludGVydmFsACUEQQFUaGUgbnVtYmVyIG9mIHJlZ2lzdHJhdGlvbiBhdHRlbXB0cyBleGNlZWRlZCB0aGUgYWxsb3dlZCBudW1iZXIgaW4gdGhlIGludGVydmFsLnxUcmFuc2FjdG9yQWNjb3VudFNob3VsZEJlSG90S2V5ACYEoFRoZSBob3RrZXkgaXMgcmVxdWlyZWQgdG8gYmUgdGhlIG9yaWdpbi44RmF1Y2V0RGlzYWJsZWQAJwRMRmF1Y2V0IGlzIGRpc2FibGVkLjhOb3RTdWJuZXRPd25lcgAoBExOb3QgYSBzdWJuZXQgb3duZXIukFJlZ2lzdHJhdGlvbk5vdFBlcm1pdHRlZE9uUm9vdFN1Ym5ldAApBLhPcGVyYXRpb24gaXMgbm90IHBlcm1pdHRlZCBvbiB0aGUgcm9vdCBzdWJuZXQuSFN0YWtlVG9vTG93Rm9yUm9vdAAqBBUBQSBob3RrZXkgd2l0aCB0b28gbGl0dGxlIHN0YWtlIGlzIGF0dGVtcHRpbmcgdG8gam9pbiB0aGUgcm9vdCBzdWJuZXQuVEFsbE5ldHdvcmtzSW5JbW11bml0eQArBJxBbGwgc3VibmV0cyBhcmUgaW4gdGhlIGltbXVuaXR5IHBlcmlvZC58Tm90RW5vdWdoQmFsYW5jZVRvUGF5U3dhcEhvdEtleQAsBKhOb3QgZW5vdWdoIGJhbGFuY2UgdG8gcGF5IHN3YXBwaW5nIGhvdGtleS40Tm90Um9vdFN1Ym5ldAAtBNxOZXR1aWQgZG9lcyBub3QgbWF0Y2ggZm9yIHNldHRpbmcgcm9vdCBuZXR3b3JrIHdlaWdodHMubENhbk5vdFNldFJvb3ROZXR3b3JrV2VpZ2h0cwAuBKRDYW4gbm90IHNldCB3ZWlnaHRzIGZvciB0aGUgcm9vdCBuZXR3b3JrLkxOb05ldXJvbklkQXZhaWxhYmxlAC8EaE5vIG5ldXJvbiBJRCBpcyBhdmFpbGFibGUuSERlbGVnYXRlVGFrZVRvb0xvdwAwBGREZWxlZ2F0ZSB0YWtlIGlzIHRvbyBsb3cuTERlbGVnYXRlVGFrZVRvb0hpZ2gAMQRoRGVsZWdhdGUgdGFrZSBpcyB0b28gaGlnaC5QTm9XZWlnaHRzQ29tbWl0Rm91bmQAMghhAU5vIGNvbW1pdCBmb3VuZCBmb3IgdGhlIHByb3ZpZGVkIGhvdGtleStuZXR1aWQgY29tYmluYXRpb24gd2hlbiBhdHRlbXB0aW5nIHRvIHJldmVhbCB0aGUgd2VpZ2h0cy58SW52YWxpZFJldmVhbENvbW1pdEhhc2hOb3RNYXRjaAAzBNRDb21taXR0ZWQgaGFzaCBkb2VzIG5vdCBlcXVhbCB0aGUgaGFzaGVkIHJldmVhbCBkYXRhLkxDb21taXRSZXZlYWxFbmFibGVkADQE8EF0dGVtcHRpbmcgdG8gY2FsbCBzZXRfd2VpZ2h0cyB3aGVuIGNvbW1pdC9yZXZlYWwgaXMgZW5hYmxlZFBDb21taXRSZXZlYWxEaXNhYmxlZAA1BMhBdHRlbXRwaW5nIHRvIGNvbW1pdC9yZXZlYWwgd2VpZ2h0cyB3aGVuIGRpc2FibGVkLkxMaXF1aWRBbHBoYURpc2FibGVkADYEvEF0dGVtcHRpbmcgdG8gc2V0IGFscGhhIGhpZ2gvbG93IHdoaWxlIGRpc2FibGVkPEFscGhhSGlnaFRvb0xvdwA3BJxBbHBoYSBoaWdoIGlzIHRvbyBsb3c6IGFscGhhX2hpZ2ggPiAwLjhIQWxwaGFMb3dPdXRPZlJhbmdlADgE7EFscGhhIGxvdyBpcyBvdXQgb2YgcmFuZ2U6IGFscGhhX2xvdyA+IDAgJiYgYWxwaGFfbG93IDwgMC44YENvbGRLZXlBbHJlYWR5QXNzb2NpYXRlZAA5BJBUaGUgY29sZGtleSBoYXMgYWxyZWFkeSBiZWVuIHN3YXBwZWSATm90RW5vdWdoQmFsYW5jZVRvUGF5U3dhcENvbGRLZXkAOgTUVGhlIGNvbGRrZXkgYmFsYW5jZSBpcyBub3QgZW5vdWdoIHRvIHBheSBmb3IgdGhlIHN3YXBYQ29sZGtleUlzSW5BcmJpdHJhdGlvbgA7BHRUaGUgY29sZGtleSBpcyBpbiBhcmJpdHJhdGlvbjBJbnZhbGlkQ2hpbGQAPAT0QXR0ZW1wdGluZyB0byBzZXQgYW4gaW52YWxpZCBjaGlsZCBmb3IgYSBob3RrZXkgb24gYSBuZXR3b3JrLjhEdXBsaWNhdGVDaGlsZAA9BJhEdXBsaWNhdGUgY2hpbGQgd2hlbiBzZXR0aW5nIGNoaWxkcmVuLkhQcm9wb3J0aW9uT3ZlcmZsb3cAPgSoUHJvcG9ydGlvbiBvdmVyZmxvdyB3aGVuIHNldHRpbmcgY2hpbGRyZW4uPFRvb01hbnlDaGlsZHJlbgA/BGBUb28gbWFueSBjaGlsZHJlbiBNQVggNS5MVHhSYXRlTGltaXRFeGNlZWRlZABABKBEZWZhdWx0IHRyYW5zYWN0aW9uIHJhdGUgbGltaXQgZXhjZWVkZWQuUFN3YXBBbHJlYWR5U2NoZWR1bGVkAEEEXFN3YXAgYWxyZWFkeSBzY2hlZHVsZWQuQEZhaWxlZFRvU2NoZWR1bGUAQgRYZmFpbGVkIHRvIHN3YXAgY29sZGtleUhOZXdDb2xkS2V5SXNIb3RrZXkAQwRUTmV3IGNvbGRrZXkgaXMgaG90a2V5TEludmFsaWRDaGlsZGtleVRha2UARARkQ2hpbGRrZXkgdGFrZSBpcyBpbnZhbGlkLnxUeENoaWxka2V5VGFrZVJhdGVMaW1pdEV4Y2VlZGVkAEUEiENoaWxka2V5IHRha2UgcmF0ZSBsaW1pdCBleGNlZWRlZC48SW52YWxpZElkZW50aXR5AEYEREludmFsaWQgaWRlbnRpdHkuVE1lY2hhbmlzbURvZXNOb3RFeGlzdABHBIBTdWJuZXQgbWVjaGFuaXNtIGRvZXMgbm90IGV4aXN0LkRDYW5ub3RVbnN0YWtlTG9jawBIBIxUcnlpbmcgdG8gdW5zdGFrZSB5b3VyIGxvY2sgYW1vdW50LjxTdWJuZXROb3RFeGlzdHMASQTAVHJ5aW5nIHRvIHBlcmZvcm0gYWN0aW9uIG9uIG5vbi1leGlzdGVudCBzdWJuZXQuYFRvb01hbnlVbnJldmVhbGVkQ29tbWl0cwBKBHBNYXhpbXVtIGNvbW1pdCBsaW1pdCByZWFjaGVkTEV4cGlyZWRXZWlnaHRDb21taXQASwS0QXR0ZW1wdGVkIHRvIHJldmVhbCB3ZWlnaHRzIHRoYXQgYXJlIGV4cGlyZWQuOFJldmVhbFRvb0Vhcmx5AEwEmEF0dGVtcHRlZCB0byByZXZlYWwgd2VpZ2h0cyB0b28gZWFybHkuTElucHV0TGVuZ3Roc1VuZXF1YWwATQQdAUF0dGVtcHRlZCB0byBiYXRjaCByZXZlYWwgd2VpZ2h0cyB3aXRoIG1pc21hdGNoZWQgdmVjdG9yIGlucHV0IGxlbmdodHMuYENvbW1pdHRpbmdXZWlnaHRzVG9vRmFzdABOBORBIHRyYW5zYWN0b3IgZXhjZWVkZWQgdGhlI

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

1VfbGltaXTFBQFQT3B0aW9uPENvbXBhY3Q8dTY0Pj4AAXRjb21taXRfcmV2ZWFsX3dlaWdodHNfZW5hYmxlZL0KATBPcHRpb248Ym9vbD4AAVBjb21taXRfcmV2ZWFsX3BlcmlvZMUFAVBPcHRpb248Q29tcGFjdDx1NjQ+PgABUGxpcXVpZF9hbHBoYV9lbmFibGVkvQoBME9wdGlvbjxib29sPgABKGFscGhhX2hpZ2ipCgFQT3B0aW9uPENvbXBhY3Q8dTE2Pj4AASRhbHBoYV9sb3epCgFQT3B0aW9uPENvbXBhY3Q8dTE2Pj4AAUBib25kc19tb3ZpbmdfYXZnxQUBUE9wdGlvbjxDb21wYWN0PHU2ND4+AAEcaG90a2V5c8EKAVhPcHRpb248VmVjPEFjY291bnRJZD4+AAEgY29sZGtleXPBCgFYT3B0aW9uPFZlYzxBY2NvdW50SWQ+PgABKGlkZW50aXRpZXPFCgGYT3B0aW9uPFZlYzxPcHRpb248Q2hhaW5JZGVudGl0eU9mVjI+Pj4AARRheG9uc8kKAVRPcHRpb248VmVjPEF4b25JbmZvPj4AARhhY3RpdmXNCgFET3B0aW9uPFZlYzxib29sPj4AAUB2YWxpZGF0b3JfcGVybWl0zQoBRE9wdGlvbjxWZWM8Ym9vbD4+AAE0cHJ1bmluZ19zY29yZdEKAWRPcHRpb248VmVjPENvbXBhY3Q8dTE2Pj4+AAEsbGFzdF91cGRhdGXVCgFkT3B0aW9uPFZlYzxDb21wYWN0PHU2ND4+PgABIGVtaXNzaW9u2QoBjE9wdGlvbjxWZWM8Q29tcGFjdDxBbHBoYUN1cnJlbmN5Pj4+AAEkZGl2aWRlbmRz0QoBZE9wdGlvbjxWZWM8Q29tcGFjdDx1MTY+Pj4AAShpbmNlbnRpdmVz0QoBZE9wdGlvbjxWZWM8Q29tcGFjdDx1MTY+Pj4AASRjb25zZW5zdXPRCgFkT3B0aW9uPFZlYzxDb21wYWN0PHUxNj4+PgABFHRydXN00QoBZE9wdGlvbjxWZWM8Q29tcGFjdDx1MTY+Pj4AARByYW5r0QoBZE9wdGlvbjxWZWM8Q29tcGFjdDx1MTY+Pj4AAVRibG9ja19hdF9yZWdpc3RyYXRpb27VCgFkT3B0aW9uPFZlYzxDb21wYWN0PHU2ND4+PgABLGFscGhhX3N0YWtl2QoBjE9wdGlvbjxWZWM8Q29tcGFjdDxBbHBoYUN1cnJlbmN5Pj4+AAEkdGFvX3N0YWtl3QoBhE9wdGlvbjxWZWM8Q29tcGFjdDxUYW9DdXJyZW5jeT4+PgABLHRvdGFsX3N0YWtl3QoBhE9wdGlvbjxWZWM8Q29tcGFjdDxUYW9DdXJyZW5jeT4+PgABYHRhb19kaXZpZGVuZHNfcGVyX2hvdGtleeEKAbhPcHRpb248VmVjPChBY2NvdW50SWQsIENvbXBhY3Q8VGFvQ3VycmVuY3k+KT4+AAFoYWxwaGFfZGl2aWRlbmRzX3Blcl9ob3RrZXnlCgHAT3B0aW9uPFZlYzwoQWNjb3VudElkLCBDb21wYWN0PEFscGhhQ3VycmVuY3k+KT4+AAEodmFsaWRhdG9yc9EKAWRPcHRpb248VmVjPENvbXBhY3Q8dTE2Pj4+AAEsY29tbWl0bWVudHPpCgGoT3B0aW9uPFZlYzwoQWNjb3VudElkLCBWZWM8Q29tcGFjdDx1OD4+KT4+AAChCgQYT3B0aW9uBARUAVUKAQgQTm9uZQAAABBTb21lBABVCgAAAQAApQoEGE9wdGlvbgQEVAFtAgEIEE5vbmUAAAAQU29tZQQAbQIAAAEAAKkKBBhPcHRpb24EBFQBWQIBCBBOb25lAAAAEFNvbWUEAFkCAAABAACtCgQYT3B0aW9uBARUAe0JAQgQTm9uZQAAABBTb21lBADtCQAAAQAAsQoEGE9wdGlvbgQEVAEhCgEIEE5vbmUAAAAQU29tZQQAIQoAAAEAALUKBBhPcHRpb24EBFQBXQoBCBBOb25lAAAAEFNvbWUEAF0KAAABAAC5CgQYT3B0aW9uBARUAe0EAQgQTm9uZQAAABBTb21lBADtBAAAAQAAvQoEGE9wdGlvbgQEVAEkAQgQTm9uZQAAABBTb21lBAAkAAABAADBCgQYT3B0aW9uBARUAT0CAQgQTm9uZQAAABBTb21lBAA9AgAAAQAAxQoEGE9wdGlvbgQEVAFtCgEIEE5vbmUAAAAQU29tZQQAbQoAAAEAAMkKBBhPcHRpb24EBFQBdQoBCBBOb25lAAAAEFNvbWUEAHUKAAABAADNCgQYT3B0aW9uBARUAdkGAQgQTm9uZQAAABBTb21lBADZBgAAAQAA0QoEGE9wdGlvbgQEVAF5CgEIEE5vbmUAAAAQU29tZQQAeQoAAAEAANUKBBhPcHRpb24EBFQBXQIBCBBOb25lAAAAEFNvbWUEAF0CAAABAADZCgQYT3B0aW9uBARUAX0KAQgQTm9uZQAAABBTb21lBAB9CgAAAQAA3QoEGE9wdGlvbgQEVAGBCgEIEE5vbmUAAAAQU29tZQQAgQoAAAEAAOEKBBhPcHRpb24EBFQBhQoBCBBOb25lAAAAEFNvbWUEAIUKAAABAADlCgQYT3B0aW9uBARUAfkJAQgQTm9uZQAAABBTb21lBAD5CQAAAQAA6QoEGE9wdGlvbgQEVAHtCgEIEE5vbmUAAAAQU29tZQQA7QoAAAEAAO0KAAAC8QoA8QoAAAQIAFUKAPUKAAAC+QoA+QoQQHBhbGxldF9zdWJ0ZW5zb3IgcnBjX2luZm8oc3Rha2VfaW5mbyRTdGFrZUluZm8EJEFjY291bnRJZAEAACQBGGhvdGtleQABJEFjY291bnRJZAABHGNvbGRrZXkAASRBY2NvdW50SWQAARhuZXR1aWTAATxDb21wYWN0PE5ldFVpZD4AARRzdGFrZe0JAVhDb21wYWN0PEFscGhhQ3VycmVuY3k+AAEYbG9ja2VkMAEwQ29tcGFjdDx1NjQ+AAEgZW1pc3Npb27tCQFYQ29tcGFjdDxBbHBoYUN1cnJlbmN5PgABMHRhb19lbWlzc2lvbiEKAVBDb21wYWN0PFRhb0N1cnJlbmN5PgABFGRyYWluMAEwQ29tcGFjdDx1NjQ+AAE0aXNfcmVnaXN0ZXJlZCQBEGJvb2wAAP0KAAACAQsAAQsAAAQIAPUKAAULBBhPcHRpb24EBFQB+QoBCBBOb25lAAAAEFNvbWUEAPkKAAABAAAJCwQYT3B0aW9uBARUAaUGAQgQTm9uZQAAABBTb21lBAClBgAAAQAADQsIRHNwX2NvbnNlbnN1c19iYWJlREJhYmVDb25maWd1cmF0aW9uAAAYATRzbG90X2R1cmF0aW9uGAEMdTY0AAEwZXBvY2hfbGVuZ3RoGAEMdTY0AAEEYxELASgodTY0LCB1NjQpAAEsYXV0aG9yaXRpZXMVCwGcVmVjPChBdXRob3JpdHlJZCwgQmFiZUF1dGhvcml0eVdlaWdodCk+AAEocmFuZG9tbmVzcwQBKFJhbmRvbW5lc3MAATRhbGxvd2VkX3Nsb3RzIQsBMEFsbG93ZWRTbG90cwAAEQsAAAQIGBgAFQsAAAIZCwAZCwAABAgdCxgAHQsMRHNwX2NvbnNlbnN1c19iYWJlDGFwcBhQdWJsaWMAAAQABAE8c3IyNTUxOTo6UHVibGljAAAhCwhEc3BfY29uc2Vuc3VzX2JhYmUwQWxsb3dlZFNsb3RzAAEMMFByaW1hcnlTbG90cwAAAHRQcmltYXJ5QW5kU2Vjb25kYXJ5UGxhaW5TbG90cwABAGxQcmltYXJ5QW5kU2Vjb25kYXJ5VlJGU2xvdHMAAgAAJQsIRHNwX2NvbnNlbnN1c19iYWJlFEVwb2NoAAAYASxlcG9jaF9pbmRleBgBDHU2NAABKHN0YXJ0X3Nsb3Q1BgEQU2xvdAABIGR1cmF0aW9uGAEMdTY0AAEsYXV0aG9yaXRpZXMVCwGcVmVjPChBdXRob3JpdHlJZCwgQmFiZUF1dGhvcml0eVdlaWdodCk+AAEocmFuZG9tbmVzcwQBKFJhbmRvbW5lc3MAARhjb25maWcpCwFYQmFiZUVwb2NoQ29uZmlndXJhdGlvbgAAKQsIRHNwX2NvbnNlbnN1c19iYWJlWEJhYmVFcG9jaENvbmZpZ3VyYXRpb24AAAgBBGMRCwEoKHU2NCwgdTY0KQABNGFsbG93ZWRfc2xvdHMhCwEwQWxsb3dlZFNsb3RzAAAtCwQYT3B0aW9uBARUATELAQgQTm9uZQAAABBTb21lBAAxCwAAAQAAMQsIRHNwX2NvbnNlbnN1c19iYWJlXE9wYXF1ZUtleU93bmVyc2hpcFByb29mAAAEADgBHFZlYzx1OD4AADULCEhzcF9jb25zZW5zdXNfc2xvdHNERXF1aXZvY2F0aW9uUHJvb2YIGEhlYWRlcgHhBQhJZAEdCwAQASBvZmZlbmRlch0LAQhJZAABEHNsb3Q1BgEQU2xvdAABMGZpcnN0X2hlYWRlcuEFARhIZWFkZXIAATRzZWNvbmRfaGVhZGVy4QUBGEhlYWRlcgAAOQsIhHBhbGxldF9zdWJ0ZW5zb3Jfc3dhcF9ydW50aW1lX2FwaTRTaW1Td2FwUmVzdWx0AAAQASh0YW9fYW1vdW50GAEsVGFvQ3VycmVuY3kAATBhbHBoYV9hbW91bnQYATRBbHBoYUN1cnJlbmN5AAEcdGFvX2ZlZRgBLFRhb0N1cnJlbmN5AAEkYWxwaGFfZmVlGAE0QWxwaGFDdXJyZW5jeQAAPQsIWG5vZGVfc3VidGVuc29yX3J1bnRpbWUwUnVudGltZUVycm9yAAFUGFN5c3RlbQQA9QEBcGZyYW1lX3N5c3RlbTo6RXJyb3I8UnVudGltZT4AAAAcR3JhbmRwYQQARQYBeHBhbGxldF9ncmFuZHBhOjpFcnJvcjxSdW50aW1lPgAEACBCYWxhbmNlcwQAlQYBfHBhbGxldF9iYWxhbmNlczo6RXJyb3I8UnVudGltZT4ABQA8U3VidGVuc29yTW9kdWxlBAA5BwGAcGFsbGV0X3N1YnRlbnNvcjo6RXJyb3I8UnVudGltZT4ABwAcVXRpbGl0eQQAPQcBeHBhbGxldF91dGlsaXR5OjpFcnJvcjxSdW50aW1lPgALABBTdWRvBABBBwFscGFsbGV0X3N1ZG86OkVycm9yPFJ1bnRpbWU+AAwAIE11bHRpc2lnBABRBwF8cGFsbGV0X211bHRpc2lnOjpFcnJvcjxSdW50aW1lPgANACBQcmVpbWFnZQQAeQcBfHBhbGxldF9wcmVpbWFnZTo6RXJyb3I8UnVudGltZT4ADgAkU2NoZWR1bGVyBACZBwGAcGFsbGV0X3NjaGVkdWxlcjo6RXJyb3I8UnVudGltZT4ADwAUUHJveHkEAL0HAXBwYWxsZXRfcHJveHk6OkVycm9yPFJ1bnRpbWU+ABAAIFJlZ2lzdHJ5BADFBwF8cGFsbGV0X3JlZ2lzdHJ5OjpFcnJvcjxSdW50aW1lPgARACxDb21taXRtZW50cwQA4QcBiHBhbGxldF9jb21taXRtZW50czo6RXJyb3I8UnVudGltZT4AEgAoQWRtaW5VdGlscwQA5QcBiHBhbGxldF9hZG1pbl91dGlsczo6RXJyb3I8UnVudGltZT4AEwAgU2FmZU1vZGUEAPEHAYBwYWxsZXRfc2FmZV9tb2RlOjpFcnJvcjxSdW50aW1lPgAUACBFdGhlcmV1bQQAMQgBfHBhbGxldF9ldGhlcmV1bTo6RXJyb3I8UnVudGltZT4AFQAMRVZNBAA9CAFocGFsbGV0X2V2bTo6RXJyb3I8UnVudGltZT4AFgAURHJhbmQEAEEIAXBwYWxsZXRfZHJhbmQ6OkVycm9yPFJ1bnRpbWU+ABoAJENyb3dkbG9hbgQAUQgBgHBhbGxldF9jcm93ZGxvYW46OkVycm9yPFJ1bnRpbWU+ABsAEFN3YXAEAHEIAZRwYWxsZXRfc3VidGVuc29yX3N3YXA6OkVycm9yPFJ1bnRpbWU+ABwAJENvbnRyYWN0cwQAwQgBgHBhbGxldF9jb250cmFjdHM6OkVycm9yPFJ1bnRpbWU+AB0AJE1ldlNoaWVsZAQAyQgBdHBhbGxldF9zaGllbGQ6OkVycm9yPFJ1bnRpbWU+AB4AAGwYU3lzdGVtARhTeXN0ZW1MHEFjY291bnQBAQQCAAzgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAE6CBUaGUgZnVsbCBhY2NvdW50IGluZm9ybWF0aW9uIGZvciBhIHBhcnRpY3VsYXIgYWNjb3VudCBJRC4AOEV4dHJpbnNpY0NvdW50AAAQBAAEuCBUb3RhbCBleHRyaW5zaWNzIGNvdW50IGZvciB0aGUgY3VycmVudCBibG9jay4AQEluaGVyZW50c0FwcGxpZWQBACQEAASkIFdoZXRoZXIgYWxsIGluaGVyZW50cyBoYXZlIGJlZW4gYXBwbGllZC4ALEJsb2NrV2VpZ2h0AQAoGAAAAAAAAASIIFRoZSBjdXJyZW50IHdlaWdodCBmb3IgdGhlIGJsb2NrLgBAQWxsRXh0cmluc2ljc0xlbgAAEAQABEEBIFRvdGFsIGxlbmd0aCAoaW4gYnl0ZXMp

1IGZvciBhbGwgZXh0cmluc2ljcyBwdXQgdG9nZXRoZXIsIGZvciB0aGUgY3VycmVudCBibG9jay4AJEJsb2NrSGFzaAEBBAUQNIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASYIE1hcCBvZiBibG9jayBudW1iZXJzIHRvIGJsb2NrIGhhc2hlcy4ANEV4dHJpbnNpY0RhdGEBAQQFEDgEAAQ9ASBFeHRyaW5zaWNzIGRhdGEgZm9yIHRoZSBjdXJyZW50IGJsb2NrIChtYXBzIGFuIGV4dHJpbnNpYydzIGluZGV4IHRvIGl0cyBkYXRhKS4AGE51bWJlcgEAEBAAAAAABAkBIFRoZSBjdXJyZW50IGJsb2NrIG51bWJlciBiZWluZyBwcm9jZXNzZWQuIFNldCBieSBgZXhlY3V0ZV9ibG9ja2AuAChQYXJlbnRIYXNoAQA0gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABHAgSGFzaCBvZiB0aGUgcHJldmlvdXMgYmxvY2suABhEaWdlc3QBADwEAATwIERpZ2VzdCBvZiB0aGUgY3VycmVudCBibG9jaywgYWxzbyBwYXJ0IG9mIHRoZSBibG9jayBoZWFkZXIuABhFdmVudHMBAEwEABygIEV2ZW50cyBkZXBvc2l0ZWQgZm9yIHRoZSBjdXJyZW50IGJsb2NrLgAdASBOT1RFOiBUaGUgaXRlbSBpcyB1bmJvdW5kIGFuZCBzaG91bGQgdGhlcmVmb3JlIG5ldmVyIGJlIHJlYWQgb24gY2hhaW4u0CBJdCBjb3VsZCBvdGhlcndpc2UgaW5mbGF0ZSB0aGUgUG9WIHNpemUgb2YgYSBibG9jay4ALQEgRXZlbnRzIGhhdmUgYSBsYXJnZSBpbi1tZW1vcnkgc2l6ZS4gQm94IHRoZSBldmVudHMgdG8gbm90IGdvIG91dC1vZi1tZW1vcnn8IGp1c3QgaW4gY2FzZSBzb21lb25lIHN0aWxsIHJlYWRzIHRoZW0gZnJvbSB3aXRoaW4gdGhlIHJ1bnRpbWUuAChFdmVudENvdW50AQAQEAAAAAAEuCBUaGUgbnVtYmVyIG9mIGV2ZW50cyBpbiB0aGUgYEV2ZW50czxUPmAgbGlzdC4ALEV2ZW50VG9waWNzAQEEAjSpAQQAKCUBIE1hcHBpbmcgYmV0d2VlbiBhIHRvcGljIChyZXByZXNlbnRlZCBieSBUOjpIYXNoKSBhbmQgYSB2ZWN0b3Igb2YgaW5kZXhlc5Qgb2YgZXZlbnRzIGluIHRoZSBgPEV2ZW50czxUPj5gIGxpc3QuAFEBIEFsbCB0b3BpYyB2ZWN0b3JzIGhhdmUgZGV0ZXJtaW5pc3RpYyBzdG9yYWdlIGxvY2F0aW9ucyBkZXBlbmRpbmcgb24gdGhlIHRvcGljLiBUaGlzRQEgYWxsb3dzIGxpZ2h0LWNsaWVudHMgdG8gbGV2ZXJhZ2UgdGhlIGNoYW5nZXMgdHJpZSBzdG9yYWdlIHRyYWNraW5nIG1lY2hhbmlzbSBhbmTkIGluIGNhc2Ugb2YgY2hhbmdlcyBmZXRjaCB0aGUgbGlzdCBvZiBldmVudHMgb2YgaW50ZXJlc3QuAFkBIFRoZSB2YWx1ZSBoYXMgdGhlIHR5cGUgYChCbG9ja051bWJlckZvcjxUPiwgRXZlbnRJbmRleClgIGJlY2F1c2UgaWYgd2UgdXNlZCBvbmx5IGp1c3RNASB0aGUgYEV2ZW50SW5kZXhgIHRoZW4gaW4gY2FzZSBpZiB0aGUgdG9waWMgaGFzIHRoZSBzYW1lIGNvbnRlbnRzIG9uIHRoZSBuZXh0IGJsb2NrAQEgbm8gbm90aWZpY2F0aW9uIHdpbGwgYmUgdHJpZ2dlcmVkIHRodXMgdGhlIGV2ZW50IG1pZ2h0IGJlIGxvc3QuAEh

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

1MuIFNlZSBgaHR0cHM6Ly9naXRodWIuY29tL3Bhcml0eXRlY2gvc3Vic3RyYXRlL3B1bGwvMTI5NTEvYAAoTWF4RnJlZXplcxAQMgAAAARhASBUaGUgbWF4aW11bSBudW1iZXIgb2YgaW5kaXZpZHVhbCBmcmVlemUgbG9ja3MgdGhhdCBjYW4gZXhpc3Qgb24gYW4gYWNjb3VudCBhdCBhbnkgdGltZS4AAZUGABBEUnVudGltZUhvbGRSZWFzb25tBgR0IFRoZSBvdmVyYXJjaGluZyBob2xkIHJlYXNvbi4cQmFsYW5jZRgEbCBUaGUgYmFsYW5jZSBvZiBhbiBhY2NvdW50LkRSZXNlcnZlSWRlbnRpZmllcvEBDGggVGhlIElEIHR5cGUgZm9yIHJlc2VydmVzLgCxASBVc2Ugb2YgcmVzZXJ2ZXMgaXMgZGVwcmVjYXRlZCBpbiBmYXZvdXIgb2YgaG9sZHMuIFNlZSBgaHR0cHM6Ly9naXRodWIuY29tL3Bhcml0eXRlY2gvc3Vic3RyYXRlL3B1bGwvMTI5NTEvYEBGcmVlemVJZGVudGlmaWVyjQYEZCBUaGUgSUQgdHlwZSBmb3IgZnJlZXplcy4ABQAASFRyYW5zYWN0aW9uUGF5bWVudAFIVHJhbnNhY3Rpb25QYXltZW50CEROZXh0RmVlTXVsdGlwbGllcgEAmQZAAABkp7O24A0AAAAAAAAAAAAAOFN0b3JhZ2VWZXJzaW9uAQCdBgQAAAAAAZgABGBPcGVyYXRpb25hbEZlZU11bHRpcGxpZXIIBAVUWQEgQSBmZWUgbXVsdGlwbGllciBmb3IgYE9wZXJhdGlvbmFsYCBleHRyaW5zaWNzIHRvIGNvbXB1dGUgInZpcnR1YWwgdGlwIiB0byBib29zdCB0aGVpciwgYHByaW9yaXR5YABRASBUaGlzIHZhbHVlIGlzIG11bHRpcGxpZWQgYnkgdGhlIGBmaW5hbF9mZWVgIHRvIG9idGFpbiBhICJ2aXJ0dWFsIHRpcCIgdGhhdCBpcyBsYXRlcvQgYWRkZWQgdG8gYSB0aXAgY29tcG9uZW50IGluIHJlZ3VsYXIgYHByaW9yaXR5YCBjYWxjdWxhdGlvbnMuTQEgSXQgbWVhbnMgdGh

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

1hdGlvbgkLbGRlc3RpbmF0aW9uX2NvbGRrZXlfYWNjb3VudAAYYW1vdW50GBgAAAAEAHBTdWJuZXRSZWdpc3RyYXRpb25SdW50aW1lQXBpBHRnZXRfbmV0d29ya19yZWdpc3RyYXRpb25fY29zdAAYAAAABAAcQmFiZUFwaRg0Y29uZmlndXJhdGlvbgANCwSMIFJldHVybiB0aGUgY29uZmlndXJhdGlvbiBmb3IgQkFCRS4ATGN1cnJlbnRfZXBvY2hfc3RhcnQANQYExCBSZXR1cm5zIHRoZSBzbG90IHRoYXQgc3RhcnRlZCB0aGUgY3VycmVudCBlcG9jaC4ANGN1cnJlbnRfZXBvY2gAJQsExCBSZXR1cm5zIGluZm9ybWF0aW9uIHJlZ2FyZGluZyB0aGUgY3VycmVudCBlcG9jaC4AKG5leHRfZXBvY2gAJQsIAQEgUmV0dXJucyBpbmZvcm1hdGlvbiByZWdhcmRpbmcgdGhlIG5leHQgZXBvY2ggKHdoaWNoIHdhcyBhbHJlYWR5XCBwcmV2aW91c2x5IGFubm91bmNlZCkuAHBnZW5lcmF0ZV9rZXlfb3duZXJzaGlwX3Byb29mCBBzbG90NQYwYXV0aG9yaXR5X2lkHQstCywJASBHZW5lcmF0ZXMgYSBwcm9vZiBvZiBrZXkgb3duZXJzaGlwIGZvciB0aGUgZ2l2ZW4gYXV0aG9yaXR5IGluIHRoZQ0BIGN1cnJlbnQgZXBvY2guIEFuIGV4YW1wbGUgdXNhZ2Ugb2YgdGhpcyBtb2R1bGUgaXMgY291cGxlZCB3aXRoIHRoZQUBIHNlc3Npb24gaGlzdG9yaWNhbCBtb2R1bGUgdG8gcHJvdmUgdGhhdCBhIGdpdmVuIGF1dGhvcml0eSBrZXkgaXMNASB0aWVkIHRvIGEgZ2l2ZW4gc3Rha2luZyBpZGVudGl0eSBkdXJpbmcgYSBzcGVjaWZpYyBzZXNzaW9uLiBQcm9vZnMRASBvZiBrZXkgb3duZXJzaGlwIGFyZSBuZWNlc3NhcnkgZm9yIHN1Ym1pdHRpbmcgZXF1aXZvY2F0aW9uIHJlcG9ydHMuCQEgTk9URTogZXZlbiB0aG91Z2ggdGhlIEFQSSB0YWtlcyBhIGBzbG90YCBhcyBwYXJhbWV0ZXIgdGhlIGN1cnJlbnQJASBpbXBsZW1lbnRhdGlvbnMgaWdub3JlcyB0aGlzIHBhcmFtZXRlciBhbmQgaW5zdGVhZCByZWxpZXMgb24gdGhpcw0BIG1ldGhvZCBiZWluZyBjYWxsZWQgYXQgdGhlIGNvcnJlY3QgYmxvY2sgaGVpZ2h0LCBpLmUuIGFueSBwb2ludCBhdPAgd2hpY2ggdGhlIGVwb2NoIGZvciB0aGUgZ2l2ZW4gc2xvdCBpcyBsaXZlIG9uLWNoYWluLiBGdXR1cmUJASBpbXBsZW1lbnRhdGlvbnMgd2lsbCBpbnN0ZWFkIHVzZSBpbmRleGVkIGRhdGEgdGhyb3VnaCBhbiBvZmZjaGFpbtAgd29ya2VyLCBub3QgcmVxdWlyaW5nIG9sZGVyIHN0YXRlcyB0byBiZSBhdmFpbGFibGUuALRzdWJtaXRfcmVwb3J0X2VxdWl2b2NhdGlvbl91bnNpZ25lZF9leHRyaW5zaWMISGVxdWl2b2NhdGlvbl9wcm9vZjULPGtleV9vd25lcl9wcm9vZjELMQkgEQEgU3VibWl0cyBhbiB1bnNpZ25lZCBleHRyaW5zaWMgdG8gcmVwb3J0IGFuIGVxdWl2b2NhdGlvbi4gVGhlIGNhbGxlcvggbXVzdCBwcm92aWRlIHRoZSBlcXVpdm9jYXRpb24gcHJvb2YgYW5kIGEga2V5IG93bmVyc2hpcCBwcm9vZvwgKHNob3VsZCBiZSBvYnRhaW5lZCB1c2luZyBgZ2VuZXJhdGVfa2V5X293bmVyc2hpcF9wcm9vZmApLiBUaGUFASBleHRyaW5zaWMgd2lsbCBiZSB1bnNpZ25lZCBhbmQgc2hvdWxkIG9ubHkgYmUgYWNjZXB0ZWQgZm9yIGxvY2FsFQEgYXV0aG9yc2hpcCAobm90IHRvIGJlIGJyb2FkY2FzdCB0byB0aGUgbmV0d29yaykuIFRoaXMgbWV0aG9kIHJldHVybnMJASBgTm9uZWAgd2hlbiBjcmVhdGlvbiBvZiB0aGUgZXh0cmluc2ljIGZhaWxzLCBlLmcuIGlmIGVxdWl2b2NhdGlvbgUBIHJlcG9ydGluZyBpcyBkaXNhYmxlZCBmb3IgdGhlIGdpdmVuIHJ1bnRpbWUgKGkuZS4gdGhpcyBtZXRob2QgaXMFASBoYXJkY29kZWQgdG8gcmV0dXJuIGBOb25lYCkuIE9ubHkgdXNlZnVsIGluIGFuIG9mZmNoYWluIGNvbnRleHQuAAS4IEFQSSBuZWNlc3NhcnkgZm9yIGJsb2NrIGF1dGhvcnNoaXAgd2l0aCBCQUJFLggAOFN3YXBSdW50aW1lQXBpDExjdXJyZW50X2FscGhhX3ByaWNlBBhuZXR1aWSgGAAAWHNpbV9zd2FwX3Rhb19mb3JfYWxwaGEIGG5ldHVpZKAMdGFvGDkLAABYc2ltX3N3YXBfYWxwaGFfZm9yX3RhbwgYbmV0dWlkoBRhbHBoYRg5CwAAAAQA+QFUPQsA"}}]);