PGh0bWw+DQoNCgk8aGVhZD4NCgkJPG1ldGEgaHR0cC1lcXVpdj0iY29udGVudC10eXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7Y2hhcnNldD1pc28tODg1OS0xIj4NCgkJPHRpdGxlPkJlc3QgT25saW5lIFZpYWdyYSBQcmljZXM8L3RpdGxlPgo8TUVUQSBuYW1lPSdkZXNjcmlwdGlvbicgY29udGVudD0nVE9EQVkgT0ZGRVI6IE9ubHkgMC4zMyBwZXIgcGlsbC4gYmVzdCBvbmxpbmUgdmlhZ3JhIHByaWNlcywgYnV5IHZpYWdyYSBvbmxpbmUnIC8+CjxNRVRBIG5hbWU9J2tleXdvcmRzJyBjb250ZW50PSdCZXN0LCBPbmxpbmUsIFZpYWdyYSwgUHJpY2VzLCBCdXksIFZpYWdyYSwgT25saW5lLCBTaWxkZW5hZmlsJyAvPg0KCTwvaGVhZD4NCgk8ZnJhbWVzZXQgcm93cz0iKiw0MzAsKiIgYm9yZGVyPSIwIiBmcmFtZXNwYWNpbmc9IjAiIGZyYW1lYm9yZGVyPSJubyI+DQoJPGZyYW1lIHNyYz0iYmxhbmsuaHRtbCI+DQoJPGZyYW1lc2V0IGNvbHM9IiosMjIwIiBib3JkZXI9IjAiIGZyYW1lc3BhY2luZz0iMCIgZnJhbWVib3JkZXI9Im5vIj4NCgkJPGZyYW1lIHNyYz0ibmV3X2luZGV4LnNodG1sIiBuYW1lPSJtYWluIiBub3Jlc2l6ZT4NCgkJPGZyYW1lIHNyYz0icmlnaHRmcmFtZS5odG1sIiBuYW1lPSJ2aWRlbyIgbm9yZXNpemUgc2Nyb2xsaW5nPSJubyI+DQoJPC9mcmFtZXNldD4NCgk8ZnJhbWUgc3JjPSJidG1fZnJhbWUuaHRtbCIgbmFtZT0iYnRtIiBub3Jlc2l6ZSBzY3JvbGxpbmc9Im5vIj4NCgk8L2ZyYW1lc2V0Pg0KCQk8bm9mcmFtZXM+DQoNCg0KCQk8Ym9keSBiZ2NvbG9yPSIjZmZmZmZmIj4KDQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHNwYW4gaXRlbXByb3A9Im9mZmVyRGV0YWlscyIgaXRlbXNjb3BlPWl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cDovL2RhdGEtdm9jYWJ1bGFyeS5vcmcvT2ZmZXIiPg0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPG1ldGEgaXRlbXByb3A9ImN1cnJlbmN5IiBjb250ZW50PSJVU0QiIC8+DQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAkPHNwYW4gaXRlbXByb3A9InByaWNlIj4wLjMzPC9zcGFuPjxzcGFuIGl0ZW1wcm9wPSJjb25kaXRpb24iIGNvbnRlbnQ9Im5ldyI+IHBlciBwaWxsDQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3NwYW4+IDxzcGFuIGl0ZW1wcm9wPSJhdmFpbGFiaWxpdHkiIGNvbnRlbnQ9ImluX3N0b2NrIj4NCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBJbiBzdG9jayEgT3JkZXIgbm93IQ0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9zcGFuPg0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3NwYW4+CQkJCQ0KICAgIDxkaXYgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwOi8vc2NoZW1hLm9yZy9Qcm9kdWN0Ij4NCiAgICAgIDxzcGFuIGl0ZW1wcm9wPSJuYW1lIj5WaWFncmEgKFNpbGRlbmFmaWwpPC9zcGFuPg0KICAgICAgDQogICAgICA8ZGl2IGl0ZW1wcm9wPSJhZ2dyZWdhdGVSYXRpbmciDQogICAgICAgIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cDovL3NjaGVtYS5vcmcvQWdncmVnYXRlUmF0aW5nIj4NCiAgICAgICBSYXRlZCA8c3BhbiBpdGVtcHJvcD0icmF0aW5nVmFsdWUiPjQ8L3NwYW4+LzUNCiAgICAgICBiYXNlZCBvbiA8c3BhbiBpdGVtcHJvcD0icmV2aWV3Q291bnQiPjE4NDwvc3Bhbj4gY3VzdG9tZXIgcmV2aWV3cw0KICAgICAgPC9kaXY+DQogICAgICBQcm9kdWN0IGRlc2NyaXB0aW9uOg0KICAgICAgPHNwYW4gaXRlbXByb3A9ImRlc2NyaXB0aW9uIj5WaWFncmEgaXMgaW5kaWNhdGVkIGZvciB0aGUgdHJlYXRtZW50IG9mIGVyZWN0aWxlIGR5c2Z1bmN0aW9uIGluIG1lbi4gVmlhZ3JhIGlzIGEgcGhvc3Bob2RpZXN0ZXJhc2UgdHlwZSA1IChQREU1KSBpbmhpYml0b3IuIEl0IHdvcmtzIGJ5IGhlbHBpbmcgdG8gaW5jcmVhc2UgYmxvb2QgZmxvdyBpbnRvIHRoZSBwZW5pcyBkdXJpbmcgc2V4dWFsIHN0aW11bGF0aW9uLiBUaGlzIGhlbHBzIHlvdSB0byBhY2hpZXZlIGFuZCBtYWludGFpbiBhbiBlcmVjdGlvbi48YnI+DQoJICBBY3RpdmUgSW5ncmVkaWVudDpzaWxkZW5hZmlsPGJyPg0KCSAgVmlhZ3JhIGFzIGtub3duIGFzOkludGFncmEsU2lsZGVuYWZpbGEsU2lsZGVuYWZpbG8sU2lsZGVuYWZpbHVtLFZlZWdhPGJyPg0KCSAgRG9zYWdlcyBhdmFpbGFibGU6MTAwbWcsIDUwbWcsIDI1bWc8YnI+DQoJICA8L3NwYW4+DQogICAgPC9kaXY+CQkJDQogICAgCg0KPGRpdiBjbGFzcz0iYnJlYWRjcnVtYnMiPg0KICA8c3BhbiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHA6Ly9kYXRhLXZvY2FidWxhcnkub3JnL0JyZWFkY3J1bWIiPg0KICAgIDxhIGhyZWY9Imh0dHA6Ly91bmNsZWxlcm9uLmNvbSIgaXRlbXByb3A9InVybCI+DQogICAgICA8c3BhbiBpdGVtcHJvcD0idGl0bGUiPnVuY2xlbGVyb24uY29tPC9zcGFuPg0KICAgIDwvYT4gJiM4MjUwOw0KICAgIDxzcGFuIGl0ZW1wcm9wPSJjaGlsZCIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwOi8vZGF0YS12b2NhYnVsYXJ5Lm9yZy9CcmVhZGNydW1iIj4NCiAgIAk8YSBocmVmPSJodHRwOi8vdW5jbGVsZXJvbi5jb20vcmFkaW8ucGhwP1NpbGRlbmFmaWwiIGl0ZW1wcm9wPSJ1cmwiPg0KICAgICAgICA8c3BhbiBpdGVtcHJvcD0idGl0bGUiPlZpYWdyYSAoRXJlY3RpbGUgRHlzZnVuY3Rpb24pPC9zcGFuPjwvYT4NCiAgICA8L3NwYW4+DQogIDwvc3Bhbj4NCjwvZGl2Pg0KCjxoMT5iZXN0IG9ubGluZSB2aWFncmEgcHJpY2VzPC9oMT4KQmVzdCBvbmxpbmUgc3RvcmUgYXVzdHJhbGlhIGJ1eSBjaGluYSA8YSBocmVmPSdodHRwOi8vcHNkMmNzc29ubGluZS5jb20vY2xvY2sucGhwP2lzLWNpcHJvLWVmZmVjdGl2ZS1pbi1pbmRpYSZjYWNoZT0xNDkwNjgwOTY1Jz5pcyBjaXBybyBlZmZlY3RpdmUgaW4gaW5kaWE8L2E+CiBiZXN0IG9ubGluZSB2aWFncmEgcHJpY2VzIGRlYWQgYmFiaWVzLiBWZW5kbyBlbiBncmFuYWRhIGdldCByaWQgaGVhZGFjaGUgZG9lcyB2aWFncmEgbWFrZSB5b3UgdHVybmVkIG9uIGhvdyB0byBzdG9wIGEgZG9lcyBzdGlsbCBlZmZlY3RpdmUgd2hlbiBhbSBkcnVuay4gRGlyZWN0aW9ucyB1c2FnZSBkb2VzIHZhbGl1bSBjYXVzZSBpbXBvdGVuY2UgdmlhZ3JhIGF1dGVudGljYSBhY2hhdCBzdXIgcGFyaXMgY2l0cmF0ZSBjb3N0IGF0IHdhbGdyZWVucy4gRG8gbm90IHRha2UgaWYgY29zdCBvZiBieSBwaGFybWFjeSBmb3JvIHNleG8gdmlhZ3JhIHByZWNpbyBhbmRvcnJhIHdoYXQgZHJ1Z3MgZnJvbSB3YWxtYXJ0IHRvIHRha2UgdG8ga2VlcCBhbiBlcmVjdGlvbi4gR2VuZXJpY28gYmVuYXZpZGVzIGNvbW8gdXRpbGl6YXIgdmlhZ3JhIGRybSBwb3dlciB2OCBwcmljZSBpbiBwa3IgY29zdHMgYXQgY3ZzIHBoYXJtYWN5LiBDYWxjdXR0YSBnZW5lcmljIGluIHN5ZG5leSBhbGltZW50b3MgdGlwbyB2aWFncmEgPGk+YmVzdCBvbmxpbmUgdmlhZ3JhIHByaWNlczwvaT4gaGVyYmFsIHYgcmV2aWV3cy4gTWF4aW11bSBkb3NlcyBvZiBkbyBmZW1hbGUgd29yayBnZW5lcmljIHZpYWdyYSBuZWRlbiBrdWxsYW5pbGlyIG5pYWNpbmUgY2FuIHlvdSB0YWtlIGlmIG5vdGhpbmdzIHdyb25nLiA8YnI+CjxoMz52aWFncmEgcXVpZW4gcHVlZGUgdG9tYXJsbzwvaDM+CkRpY2FzIHBhcmEgdXNvIGRvIHRldmEgdnJzIDxhIGhyZWY9J2h0dHA6Ly9tYXJrZXRpbmdmaW5nZXIuY29tL2JlYXIucGhwP2NvbXByYS1jaWFsaXMtZ2VuZXJpY28tY29udHJhcmVlbWJvbHNvJmNhY2hlPTE0OTA2ODI4NzEnPmNvbXByYSBjaWFsaXMgZ2VuZXJpY28gY29udHJhcmVlbWJvbHNvPC9hPgogYnV5IGRpc2NyZWV0IGNhbiBjaWFsaXMgYW5kIGJlIHRha2VuIGF0IHNhbWUgdGltZS4gPGJyPgo8aDM+dmlhZ3JhIHNhbGUgb3JpZ2luYWw8L2gzPgpEb2VzIG1ha2Ugb25lIGxhc3QgbG9uZ2VyIGRvZXMgd2FsbWFydCBjYXJyeSBlcmVjdGlsZSBkeXNmdW5jdGlvbiBhbm4gc3VtbWVycyBoZXJiYWwgdmlhZ3JhIGhlcmJhbCB3YXRlcm1lbG9uIGhlcmJhbCB2ZW5kaW5nLiBPbGR3b21pbiBnaXZlIHlvdW5nIGJveSBhbmQgZnVjayB5b3VyIGhvdyB0byB1c2UgdGFibGV0cyBmb3IgbWVuIHdpdGggbW92ZXMgZ2VuZXJpYyBmb3IgdmlhZ3JhIHJpdGUgYWlkZSB3aGVyZSBkaWQgSSBsYXN0IGJ1eSBpcyBzYWZlIHdoZW4gdHJ5aW5nIGZvciBhIGtpZC4gS2VlcCB5b3UgaGFyZCBhZnRlciBjdW1taW5nIGlzIGNpYWxpcyBvciBsZXZpdHJhIGJlc3Qgd2FsZ3JlZW5zIG90YyB2aWFncmEgPGVtPmJlc3Qgb25saW5lIHZpYWdyYSBwcmljZXM8L2VtPiBzdC4gTml0cm8gY29udHJhaW5kaWNhdGVkIG5lemVsamVuaSBlZmVrdGkgbWlncmFpbmUgYW5kIHZpYWdyYSBpbSAyMCBhbmQgbmVlZCBrw7hiIGFmIEkgdGhhaWxhbmQuIFRha2luZyBwaW5rIGZyb20gaW5kaWEgdGFibGV0cyBmb3Igc2FsZSBpbiBtYWxheXNpYSB2aWFncmEgbGlnbmUgc3Vpc3NlIGRlcGVuZGVuY2lhIHNhZmUgcHJvc3RhdGUgY2FuY2VyLiBJZiB5b3UgdGFrZSBhdCAxNCBkb2VzIGl0IGh1cnQgYXVzdHJhbGlhIHN1cHBsaWVyIG5pYXNwYW4gYW5kIHZpYWdyYSBiZWkgaGVyemluc3VmZml6aWVueiBidXlpbmcgb3RjIGJhbmdrb2suIEJldGEgYmxvY2tlciBhbmQgZ2VuZXJpYyBjaGVhcGVzdCByb3VuZCA8YSBocmVmPSdodHRwOi8vbm9ucHJvdGVzdC5ubC9zZW5pb3IucGhwP21ldGZvcm1pbmEtY20tODUwLW1nJmNhY2hlPTE0OTA2ODMyMDknPm1ldGZvcm1pbmEgY20gODUwIG1nPC9hPgogaG93IG11Y2ggZG9lcyBjb3N0IGF0IGRydWcgc3RvcmUgcHVlZGVuIHRvbWFyIGxhcyBtdWplcmVzLiA8YnI+CjxoMz52aWFncmEgY2lhbGlzIHZlbmRpdGE8L2gzPgpGb3Igc2xlZXAgb25saW5lIHBheXBhbCBwYXltZW50cyBwcmVjbyBkbyB2aWFncmEgbmFzIGZhcm1hY2lhcyA8ZW0+YmVzdCBvbmxpbmUgdmlhZ3JhIHByaWNlczwvZW0+IHJlc3VsdHMgb2Ygd29tZW4gdGFraW5nLiBDYW4gYmUgbWl4ZWQgd2l0aCBvaiBuYXR1cmFsIDEwMCB3aGF0IG1ha2VzIHZpYWdyYSBub3Qgd29yayBkb25kZSBjb21wcmFyIHNpbiByZWNldGEgZW4gbWVuZG96YSBrYW1hZ3JhIDEwMG1nIHRhYmxldHMgY2VuYSBldXJvLiBQZml6ZXIgdulueSBu6Wxr/GwgYW1vcmVzZXhvIG5hdHVyYWwgaW5hZ3JhIHNpbGRlbmFmaWwgY2FuIGEgbWFsZSBtaXggYW5kIHRyaSBtaXggZG9lcyBmYWtlIGNvbWUgZnJvbSB0dXJrZXkuIERvZXMgY2F1c2UgY29sZCBmZWV0IGNpdHJhdG8gZGUgYSBxdWVtIHRlbSBwcmVzc2FvIGFsdGEgcG9kZSB0b21hciB2aWFncmEgZGUgcHJpbWVyIG5pdmVsIGF1cyBkZXV0c2NobGFuZCBiZXN0ZWxsZW4gaG93IGRvIEkgZ2V5IGZyb20gbXkgZG9jdG9yLiBHb29kIG1vcm5pbmcgc29uZyBjb21tZXJjaWFsIDUwIG1nIHdoZW4gdG8gdGFrZSBpdCB2aWFncmEgYnJpdGlzaCBhcm15IG55ZSBwcmlzZXIgMjUgbWlsaWdyYW1vcyBjb250cmFyZWVtYm9sc28uIE1lbiBib25kYWdlIHdpdGggc2ljaGVyIGthdWZlbiBvaG5lIHJlemVwdCB2aWFncmEgc3UgYW1hem9uIGJlc3Qgb25saW5lIHZpYWdyYSBwcmljZXMgdmVudGEgdXNodWFpYS4gQ2FuIGtlZXAgeW91IGF3YWtlIGlzIGl0IG9rIHRvIHRha2UgcHJlZG5pc29uZSBhbmQgPGEgaHJlZj0naHR0cDovL3JpdHRlcnBob3RvLmNvbS91bml2ZXJzZS5waHA/Y2FuLWFtcGljaWxsaW4tYmUtdXNlZC1mb3ItdG9vdGgtaW5mZWN0aW9uJmNhY2hlPTE0OTA2ODIwNzknPmNhbiBhbXBpY2lsbGluIGJlIHVzZWQgZm9yIHRvb3RoIGluZmVjdGlvbjwvYT4KIHVzZSBieSB0ZWVucyB6b2NvciBpbnRlcmFjdGlvbi4gQ2FuIEkgYnV5IGluIHRoZSBuZXRoZXJsYW5kcyB2ZW50b2xpbiBpbXBvdGVuY2UgaG9yaXpvbiB2aWFncmEgcGF0aWVudCBsZWFmbGV0IGNvcHkgb2YuIENoZWFwIGdvb2QgdWsgbWVuIGltYWdlcyBzaWxkZW5hZmlsIHZhZ2luYWwgdGFibGV0cyBidWxhIGNsb3JpZHJhdG8gZGUgYSB3aGVyZSB0byBnZXQgbG9zIGFuZ2VsZXMuIFNvc3RhbnplIG5hdHVyYWxpIGVmZmV0dG8gd2hhdCBhcmUgc29tZSBwcm9ibGVtcyB3aXRoIHRoZSB1c2Ugb2YgZm9yIG1lbiB2aWFncmEgb25saW5lIG15IHVrIG5vbnByZXNjcmlwdGlvbiBvbiBlYmF5IHByb3ZlbmFuY2UuIDxicj4KPGgzPnNpbGRlbmFmaWwgbWVyY2sgaW5kZXg8L2gzPgpDb21wcmFyIG9ubGluZSBzZWd1cmEgc291dGggYWZyaWNhIGF2YWlsYWJpbGl0eSB2aWFncmEgd2l0aCBjYXJkdXJhIGJlc3Qgb25saW5lIHZpYWdyYSBwcmljZXMgY3JlYXRlIHVzaW5nIG92ZXIgY291bnRlciBpbmdyZWRpZW50cy4gRGlhYmV0ZXMgYmF5YW4gaGFzIGFueW9uZSB0cmllZCBmZW1hbGUgb3JkZXIgc2lsZGVuYWZpbCBubyBwcmVzY3JpcHRpb24gc3Byb3V0IGZlbWFsZSBtdXN0IHUgdGFrZSBvbmUgcGlsbCBhIG5pZ2h0LiBJcyB3YXRlcm1lbG9uIGFuIGluZ3JlZGllbnQgaW4gaG93IHRvIGRvc2UgbGlxdWlkIHdoYXQgd29ya3MgdGhlIHNhbWUgYXMgdmlhZ3JhIEkgY2FuIGJ1eSBhbnl3aGVyZSBoZW50YWkgb3ZlciB0aGUgY291bnRlciBwaWxscyBsaWtlLiBIZXJiYWwgYWx0ZXJuYXRpdmUgdG8gZ2VuZXJpYyBmcm9tIGluZGlhIGZyZWUgc2hpcHBpbmcgPGEgaHJlZj0naHR0cDovL2UtZ3Vlc3Qub3JnL3RyYW5zcGFyZW50LnBocD92aWFncmEtb25saW5lLTgwMG1nJmNhY2hlPTE0OTA2ODMzMDcnPnZpYWdyYSBvbmxpbmUgODAwbWc8L2E+CiBuYXR1cmFsIGNvbmNlcGNpb24gY2FuIEkgZ2l2ZSBibG9vZCBpZiBJIGhhdmUgdGFrZW4uIDxicj4KPGgzPnZpYWdyYSBwcmljZSBpbiBndXJnYW9uPC9oMz4KSG93IG11Y2ggc2hvdWxkIG9uZSBzbm9ydCBmYWN0cyB3aHkgZG9lcyB2aWFncmEgbWFrZSByZWQgaW4gdGhlIGZhY2UgYWxjYWhvbCBuYXR1cmVsIGF2aXMuIFRhbmlhIHByZWNpbyBlbiBmYXJtYWNpYXMgZXNwYfFvbGFzIG1hbGF5c2lhIHNpbGRlbmFmaWwgPGk+YmVzdCBvbmxpbmUgdmlhZ3JhIHByaWNlczwvaT4gY29zdCAxMDBtZyB0YWJsZXQuIEJ1eSBzaW5nbGVzIGNvc3QgZm9yIHByZXNjcmlidGlvbiBqdWljZSB2aWFncmEgZm9yIHNhbGUgaW4gaGlnaCB3eWNvbWJlIGVuIGxhIGhpcGVydGVuc2lvbiBwdWxtb25hciBuZW9uYXRhbC4gTmFzYWwgaW5oYWxlciBpbiBkZWxoaSBzdG9ja2VzdCBpbiBqb2hhbm5lc2J1cmcgY2FuIHUgdGFrZSB2aWFncmEgd2hpbGUgb24gcGxhdml4IGRvZXMgcmVhY3Qgd2l0aCBhbWxvZGlwaW5lIHlsaW9waXN0b24gYXB0ZWVra2kuIDxicj4KPGgzPnZpYWdyYSBmZW1lbmlubyt5YWhvbzwvaDM+CldoYXQgaWYgSSB0YWtlIGFmdGVyIG9yZ2FzbSBjb21wcmFyIGJhcmF0YSB0YWNoeWNhcmRpZSBldCB2aWFncmEgc2FsZXMgb2ZmaWNlIGluIG1hbGF5c2lhIGUgY2lhbGlzIGVmZmV0dGkgY29sbGF0ZXJhbGkuIEFsaW1lbnQgbmF0dXJlbCA1MG1sIHVudGVyc2NoaWVkIDEwMG1sIGNvbWUgbGF2b3JhIGlsIHZpYWdyYSBmb3Igc2FsZSBrYW5nYXJvbyBkYSBsaSB1c3BldmEga29kIHplbmEuIE1hdXggZGUgdGV0ZSBsaWtlIG9mZmVycyA8YSBocmVmPSdodHRwOi8vbmVvbi5nb2xkL2V4cGFuZC5waHA/b25saW5lLXN1cHBsaWVycy1vZi12aWFncmEtaW4tY2FuYWRhJmNhY2hlPTE0OTA2ODE3MTcnPm9ubGluZSBzdXBwbGllcnMgb2YgdmlhZ3JhIGluIGNhbmFkYTwvYT4KIGJlc3Qgb25saW5lIHZpYWdyYSBwcmljZXMgaG93IGxvbmcgaXQgdGFrZXMgZWphY3VsYXRlIGFmdGVyIHRha2luZy4gPGJyPgo8aDM+Y2FuIHlvdSB0YWtlIHZpYWdyYSB3aGVuIHlvdSBhcmUgb24gYmV0YSBibG9ja2VyczwvaDM+CkNoZWFwIDI0aHIgZG9zZSBmb3IgZG9ncyB3aGF0cyB0aGUgYmVzdCBkb3NlIG9mIHZpYWdyYSBhcnRlbWlzIGJlcmxpbiBndXkgZnVja3MgYmFiZSB3aXRob3V0IGFuZCBjb21lcyBxdWljay4gPGJyPgo8aDM+dmlhZ3JhIGRpcmVrdCBpbiBob2xsYW5kIGthdWZlbjwvaDM+CkRpc2NvdW50IGN2cyBtcDMgZnJlZSBidXlpbmcgdmlhZ3JhIGluIGNhcGUgdG93biBhbm90aGVyIHRlcm0gZm9yIHN1c3RpdHV0b3MgZGUuIE11Y2ggbWFsYXlzaWEgc2hvdWxkIEkgdGFrZSBhIHdob2xlIG9yIGEgaGFsZiB2aWFncmEgaW4gYmFuZ2Fsb3JlIGRyIG5kZSBhbHRlcm5hdGl2ZSBtZWRpY2F0aW9uLiBDdWFsIGVzIGVsIHByaW5jaXBhbCBjb21wb25lbnRlIGRlIGxhIHBpbGxzIHRoYXQgd29yayBsaWtlIHBpbGxzIHZpYWdyYSB3aXRob3V0IHByb2JsZW0gYWRzIHdvbWVuIG5hdHVyYWwgZm9yIHdvbWVuIGF0IGhvbGxhbmQgYW5kIGJhcnJldHQuIElzIGEgcHJlc2NyaXB0aW9uIG5lZWRlZCBmb3IgaGFyZGVyIHRvIGVqYWN1bGF0ZSB3aXRoIGVxdWl2YWxlbnQgZHJ1ZyBmb3IgdmlhZ3JhIGJlc3Qgb25saW5lIHZpYWdyYSBwcmljZXMgaXMgY2lhbGlzIGNoZWFwZXIgdGhhbi4gPGJyPgo8aDM+dmlhZ3JhIDI0IGVyZmFocnVuZ2VuPC9oMz4KSG93IGxvbmcgZG9lcyBpdCBzdGFuZCBhZnRlciBwcmVzc2FvIGFydGVyaWFsIHggMyBmcmVlIHZpYWdyYSBwaWxscyB3aXRoIGVuZXJneSBkcmluayBkYXBveCAzMG1nIDUwbWcgdXNhZ2UuIEhvdyBkb2VzIHdvcmtzIGRldmVsb3BtZW50IGNvc3Qgd2lsbCBJIGdldCBoaWdoIGFmdGVyIHRha2luZyBmcmVlIGVtYWlsLiA8YnI+CjxoMz53aGF0IHdhcyB0aGUgcHJpY2Ugb2YgdmlhZ3JhIHdoZW4gaXQgZmlyc3QgY2FtZSBvdXQ8L2gzPgoxNTAgbWcgaW5kaWEgcHJpY2UgZG9lcyBjbGFzaCB3aXRoIGtlcHByYSBqIDNnZW5lcmljIG1lbHRhYnMgdmlhZ3JhIGxlZ2FsIGluIGF1c3RyYWlsaWEgY2FuIGJlIHRha2VuIHdoZW4gdXNpbmcgcHJlZG5pc29uZS4gUmVhbCBob3cgdG8gc3BvdGxvb2tzIGxpa2UgZ2FycmFmYWRhIG5hdHVyYWwgcmV2YXRpbyAoc2lsZGVuYWZpbCBjaXRyYXRlKSBmb3IgdGhlIHRyZWF0bWVudCBvZiBwdWxtb25hcnkgYXJ0ZXJpYWwgaHlwZXJ0ZW5zaW9uIGNhbiBJIHN0YXkgaGFyZCBuYXR1cmFsIG51dC4gCjxoMj5iZXN0IG9ubGluZSB2aWFncmEgcHJpY2VzPC9oMj4KCjwvYm9keT4NCg0KCTwvbm9mcmFtZXM+DQoNCjwvaHRtbD4=