PGgxIHN0eWxlPSJ0ZXh0LWFsaWduOiBsZWZ0OyBmb250LXNpemU6IDI1cHg7Ij5GcmF6ZXIgQ29uc3VsdGFudHMgUHJpdmFjeSBQb2xpY3k8L2gxPg0KPHAgc3R5bGU9InRleHQtYWxpZ246IGxlZnQ7IG1hcmdpbi1ib3R0b206IDE1cHg7Ij48ZW0+TGFzdCB1cGRhdGVkOiAxLzI4LzIwMjE8L2VtPjxiciAvPjxiciAvPkZyYXplciBDb25zdWx0YW50cywgTExDICgmbGRxdW87RnJhemVyLCZyZHF1bzsgJmxkcXVvO3dlLCZyZHF1bzsgJmxkcXVvO3VzLCZyZHF1bzsgJmxkcXVvO291ciZyZHF1bzspIGlzIGNvbW1pdHRlZCB0byBwcm90ZWN0aW5nIHlvdXIgcGVyc29uYWwgaW5mb3JtYXRpb24uIFRoaXMgUHJpdmFjeSBOb3RpY2UgZGVzY3JpYmVzIHRoZSBwZXJzb25hbCBpbmZvcm1hdGlvbiB0aGF0IHdlIGNvbGxlY3QgYWJvdXQgeW91LCBob3cgd2UgdXNlIGFuZCBkaXNjbG9zZSB0aGlzIGluZm9ybWF0aW9uLCBhbmQgdGhlIHN0ZXBzIHdlIHRha2UgdG8gcHJvdGVjdCB0aGlzIGluZm9ybWF0aW9uLiBGb3IgcHVycG9zZXMgb2YgdGhpcyBQcml2YWN5IE5vdGljZSwgJmxkcXVvO3BlcnNvbmFsIGluZm9ybWF0aW9uJnJkcXVvOyBtZWFucyBhbnkgaW5mb3JtYXRpb24gdGhhdCByZWxhdGVzIHRvIHlvdSBhcyBhbiBpbmRpdmlkdWFsIGFuZCBjb3VsZCByZWFzb25hYmx5IGJlIHVzZWQgdG8gaWRlbnRpZnkgeW91LiBUaGlzIFByaXZhY3kgTm90aWNlIGFwcGxpZXMgdG8gb3VyIGNvbGxlY3Rpb24gYW5kIHVzZSBvZiBwZXJzb25hbCBpbmZvcm1hdGlvbiB0aHJvdWdoIHRoaXMgd2Vic2l0ZSBhbmQgYW55IHJlbGF0ZWQgd2Vic2l0ZXMsIGFwcGxpY2F0aW9ucywgdG9vbHMsIG9yIHBsYXRmb3JtcyAodGhlICZsZHF1bztTZXJ2aWNlcyZyZHF1bzspLCBhcyB3ZWxsIGFzIHRocm91Z2ggYW55IG90aGVyIG1lYW5zIHdoZXJlIGEgbGluayBvciByZWZlcmVuY2UgdG8gdGhpcyBQcml2YWN5IE5vdGljZSBpcyBwcm92aWRlZCBhdCB0aGUgdGltZSBvZiBjb2xsZWN0aW9uLjwvcD4NCjxoMiBzdHlsZT0idGV4dC1hbGlnbjogbGVmdDsgZm9udC1zaXplOiAyMHB4OyBwYWRkaW5nLXRvc狗NDVweDsiPk91ciBTZXJ2aWNlczwvaDI+DQo8cCBzdHlsZT0idGV4dC1hbGlnbjogbGVmdDsgbWFyZ2luLWJvdHRvbTogMTVweDsiPjxiciAvPkZyYXplciZyc3F1bztzIHByaW1hcnkgYnVzaW5lc3MgaXMgYXMgYSBzb2Z0d2FyZS1hcy1hLXNlcnZpY2UgcHJvdmlkZXIgb2YgZnVuZXJhbCB0ZWNobm9sb2d5IHNlcnZpY2VzLCBpbmNsdWRpbmcgd2Vic2l0ZSwgcGF5bWVudCBwcm9jZXNzaW5nLCBpbnN1cmFuY2UsIHNlYXJjaCBlbmdpbmUgb3B0aW1pemF0aW9uLCBtYXJrZXRpbmcgYW5kIGVjb21tZXJjZSBzZXJ2aWNlcywgdG8gZnVuZXJhbCBob21lcyBhbmQgb3RoZXIgZnVuZXJhbCBwcm9mZXNzaW9uYWxzIChvdXIgJmxkcXVvO0NsaWVudHMmcmRxdW87KS4gSW4gY29ubmVjdGlvbiB3aXRoIHRoaXMgZmFjZXQgb2YgRnJhemVyJnJzcXVvO3MgYnVzaW5lc3MsIEZyYXplciBjb2xsZWN0cyBhbmQgc3RvcmVzIHBlcnNvbmFsIGluZm9ybWF0aW9uIHJlZ2FyZGluZyBpbmRpdmlkdWFscyB3aG8gdmlzaXQgYW5kIHV0aWxpemUgY2VydGFpbiBmdW5jdGlvbnMgb3IgZmVhdHVyZXMgb2Ygb3VyIENsaWVudHMmcnNxdW87IHdlYnNpdGVzICgmbGRxdW87RW5kIFVzZXJzJnJkcXVvOykuIFRoaXMgUHJpdmFjeSBOb3RpY2UgYXBwbGllcyB0byBGcmF6ZXImcnNxdW87cyBjb2xsZWN0aW9uIGFuZCB1c2Ugb2YgQ2xpZW50IGFuZCBFbmQgVXNlciBwZXJzb25hbCBpbmZvcm1hdGlvbiBidXQgbm90IHRvIG91ciBDbGllbnRzIHVzZSBvZiBzdWNoIHBlcnNvbmFsIGluZm9ybWF0aW9uLjxiciAvPjxiciAvPkZyYXplciBhbHNvIG1haW50YWlucyBhbiBvbmxpbmUgcHJlc2VuY2UsIGluY2x1ZGluZyBhbiBlY29tbWVyY2Ugc3RvcmUsIHRoZSBUcmlidXRlIFN0b3JlLCBvZmZlcmluZyBjZXJ0YWluIGZ1bmVyYWwgcGFyYXBoZXJuYWxpYSBhbmQgcmVsYXRlZCBwcm9kdWN0cywgYW5kIGEgd2ViIHJlcG9zaXRvcnksIHRoZSBUcmlidXRlIEFyY2hpdmUsIGNvbnRhaW5pbmcgb2JpdHVhcmllcywgYSBsaXN0aW5nIG9mIGZ1bmVyYWwgaG9tZXMsIGFuZCBvdGhlciBmdW5lcmFsLXJlbGF0ZWQgY29udGVudCBpbiBjb25uZWN0aW9uIHdpdGggd2hpY2ggcGVyc29uYWwgaW5mb3JtYXRpb24gbWF5IGJlIGNvbGxlY3RlZCBmcm9tIGluZGl2aWR1YWxzICgmbGRxdW87VHJpYnV0ZSBVc2VycyZyZHF1bzspLiBUaGlzIFByaXZhY3kgTm90aWNlIGFsc28gYXBwbGllcyB0byBGcmF6ZXImcnNxdW87cyBjb2xsZWN0aW9uIGFuZCB1c2Ugb2YgcGVyc29uYWwgaW5mb3JtYXRpb24gZnJvbSBUcmlidXRlIFVzZXJzIGFuZCBvdGhlciBpbmRpdmlkdWFscyB3aG8gaW50ZXJhY3QgZGlyZWN0bHkgd2l0aCBGcmF6ZXIuPC9wPg0KPGgyIHN0eWxlPSJ0ZXh0LWFsaWduOiBsZWZ0OyBmb250LXNpemU6IDIwcHg7IHBhZGRpbmctdG9wOiA0NXB4OyI+UGVyc29uYWwgSW5mb3JtYXRpb24gV2UgQ29sbGVjdDwvaDI+DQo8cCBzdHlsZT0idGV4dC1hbGlnbjogbGVmdDsgbWFyZ2luLWJvdHRvbTogMTVweDsiPjxiciAvPldoZW4geW91IGFjY2VzcyBvciB1c2UgdGhlIFNlcnZpY2VzIG9yIG90aGVyd2lzZSBpbnRlcmFjdCB3aXRoIHVzLCB3aGV0aGVyIGFzIGEgQ2xpZW50LCBFbmQgVXNlciwgVHJpYnV0ZSBVc2VyIG9yIG90aGVyIGluZGl2aWR1YWwsIHdlIG1heSBjb2xsZWN0IGNlcnRhaW4gY2F0ZWdvcmllcyBvZiBwZXJzb25hbCBpbmZvcm1hdGlvbiBhYm91dCB5b3UgZnJvbSBhIHZhcmlldHkgb2Ygc291cmNlcy48YnIgLz48YnIgLz5DYXRlZ29yaWVzIG9mIHBlcnNvbmFsIGluZm9ybWF0aW9uIHRoYXQgd2UgbWF5IGNvbGxlY3QgZnJvbSB5b3UgZGlyZWN0bHkgaW5jbHVkZTo8L3A+DQo8dWwgc3R5bGU9InRleHQtYWxpZ246IGxlZnQ7IHBhZGRpbmctbGVmd狗MzBweDsiPg0KPGxpIHR5cGU9ImNpcmNsZSI+Q29udGFjdCBpbmZvcm1hdGlvbiAoZm9yIGV4YW1wbGUsIG5hbWUsIHBob25lIG51bWJlciwgbWFpbGluZyBhZGRyZXNzLCBlbWFpbCBhZGRyZXNzKTwvbGk+DQo8bGkgc3R5bGU9Im1hcmdpbi10b3A6IDE1cHg7IiB0eXBlPSJjaXJjbGUiPlBheW1lbnQtcmVsYXRlZCBkZXRhaWxzIChmb3IgZXhhbXBsZSwgYmlsbGluZyBhZGRyZXNzIGFuZCBvdGhlciBjcmVkaXQgY2FyZCBkZXRhaWxzKTwvbGk+DQo8bGkgc3R5bGU9Im1hcmdpbi10b3A6IDE1cHg7IiB0eXBlPSJjaXJjbGUiPkFjY291bnQgaW5mb3JtYXRpb24gKGZvciBleGFtcGxlLCB1c2VybmFtZSBhbmQgcGFzc3dvcmQgYW5kIHRyYW5zYWN0aW9uIGhpc3RvcnkpPC9saT4NCjxsaSBzdHlsZT0ibWFyZ2luLXRvc狗MTVweDsiIHR5cGU9ImNpcmNsZSI+Q29tbXVuaWNhdGlvbnMgKGZvciBleGFtcGxlLCBzdWJtaXR0ZWQgcXVlc3Rpb25zIG9yIG90aGVyIHBvc3RzIGFuZCBtYXJrZXRpbmcgcHJlZmVyZW5jZXMpPC9saT4NCjxsaSBzdHlsZT0ibWFyZ2luLXRvc狗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狗NDVweDsiPkhvdyBXZSBVc2UgWW91ciBQZXJzb25hbCBJbmZvcm1hdGlvbjwvaDI+DQo8cCBzdHlsZT0idGV4dC1hbGlnbjogbGVmdDsgbWFyZ2luLWJvdHRvbTogMTVweDsiPjxiciAvPldlIG1heSB1c2UgdGhlIHBlcnNvbmFsIGluZm9ybWF0aW9uIHdlIGNvbGxlY3QgZm9yIHRoZSBmb2xsb3dpbmcgcHVycG9zZXM6PC9wPg0KPHVsIHN0eWxlPSJ0ZXh0LWFsaWduOiBsZWZ0OyBwYWRkaW5nLWxlZnQ6IDMwcHg7Ij4NCjxsaSB0eXBlPSJjaXJjbGUiPjxzdHJvbmc+UHJvdmlkZSBhbmQgaW1wcm92ZSB0aGUgU2VydmljZXMuIDwvc3Ryb25nPldlIG1heSB1c2UgeW91ciBwZXJzb25hbCBpbmZvcm1hdGlvbiB0byBwcm92aWRlIGFuZCBpbXByb3ZlIHRoZSBTZXJ2aWNlcywgaW5jbHVkaW5nIHRvIGZ1bGZpbGwgeW91ciBvcmRlcnMgYW5kIHJlcXVlc3RzIGFuZCB0byBwb3N0IHlvdXIgY29tbWVudHMgYW5kIG90aGVyIGZ1bmVyYWwgY29udHJpYnV0aW9ucy4gV2UgbWF5IGFsc28gdXNlIHlvdXIgcGVyc29uYWwgaW5mb3JtYXRpb24gZm9yIHRoZSBhZG1pbmlzdHJhdGlvbiBvZiBvdXIgYnVzaW5lc3MsIGZvciBidXNpbmVzcyBkZXZlbG9wbWVudCBwdXJwb3NlcywgYW5kIHRvIGZ1bGZpbGwgb3VyIGNvbnRyYWN0dWFsIG9ibGlnYXRpb25zLjwvbGk+DQo8bGkgc3R5bGU9Im1hcmdpbi10b3A6IDE1cHg7IiB0eXBlPSJjaXJjbGUiPjxzdHJvbmc+UmlzayBtaXRpZ2F0aW9uIGFuZCBzZWN1cml0eS4gPC9zdHJvbmc+V2UgbWF5IHVzZSB5b3VyIHBlcnNvbmFsIGluZm9ybWF0aW9uIGZvciByaXNrIG1pdGlnYXRpb24gYW5kIHNlY3VyaXR5IHB1cnBvc2VzLCBpbmNsdWRpbmcgdG8gbWFpbnRhaW4gdGhlIHByaXZhY3kgYW5kIHNlY3VyaXR5IG9mIG91ciBkYXRhLCB0byBjb25kdWN0IGludGVybmFsIGF1ZGl0cyBvciBpbnZlc3RpZ2F0aW9ucywgZm9yIGRhdGEgc2VjdXJpdHkgdGVzdGluZyBhbmQgYnVzaW5lc3MgY29udGludWl0eSBwbGFubmluZyBwdXJwb3NlcywgYW5kIHRvIGVuc3VyZSB0aGUgc2FmZXR5IGFuZCBzZWN1cml0eSBvZiBvdXIgQ2xpZW50cywgc3RhZmYgYW5kIGFzc2V0cy48L2xpPg0KPGxpIHN0eWxlPSJtYXJnaW4tdG9wOiAxNXB4OyIgdHlwZT0iY2lyY2xlIj48c3Ryb25nPkNvbW11bmljYXRpb24gYW5kIG1hcmtldGluZy48L3N0cm9uZz4gV2UgbWF5IHVzZSB5b3VyIHBlcnNvbmFsIGluZm9ybWF0aW9uIHRvIGNvbW11bmljYXRlIHdpdGggeW91IGFib3V0IHRoZSBTZXJ2aWNlcywgcmVzcG9uZCB0byB5b3VyIHF1ZXN0aW9ucywgb3Igb2ZmZXIgeW91IGFkZGl0aW9uYWwgcHJvZHVjdHMgb3Igc2VydmljZXMuPC9saT4NCjxsaSBzdHlsZT0ibWFyZ2luLXRvc狗MTVweDsiIHR5cGU9ImNpcmNsZSI+PHN0cm9uZz5Db21wbHkgd2l0aCB0aGUgbGF3IGFuZCBleGVyY2lzZSBvdXIgcmlnaHRzLiA8L3N0cm9uZz5XZSBtYXkgdXNlIHlvdXIgcGVyc29uYWwgaW5mb3JtYXRpb24gYXMgcmVhc29uYWJseSBuZWNlc3NhcnkgdG8gYXNzZXNzIGFuZCBlbnN1cmUgY29tcGxpYW5jZSB3aXRoIGFwcGxpY2FibGUgbGF3cywgbGVnYWwgcmVxdWlyZW1lbnRzLCBhbmQgY29tcGFueSBwb2xpY2llczsgdG8gcHJvdGVjdCBvdXIgYXNzZXRzIG9yIHRvIGludmVzdGlnYXRlIG9yIGRlZmVuZCBhZ2FpbnN0IGFueSBjbGFpbXMgb2YgaWxsZWdhbGl0eSBvciB3cm9uZ2RvaW5nIChpbmNsdWRpbmcgdG8gb2J0YWluIGxlZ2FsIGFkdmljZSBvciB0byBlc3RhYmxpc2gsIGV4ZXJjaXNlIG9yIGRlZmVuZCBsZWdhbCByaWdodHMpOyBhbmQgaW4gcmVzcG9uc2UgdG8gYSBjb3VydCBvcmRlciBvciBqdWRpY2lhbCBvciBvdGhlciBnb3Zlcm5tZW50IHN1YnBvZW5hIG9yIHdhcnJhbnQuPC9saT4NCjxsaSBzdHlsZT0ibWFyZ2luLXRvc狗MTVweDsiIHR5cGU9ImNpcmNsZSI+PHN0cm9uZz5Db3Jwb3JhdGUgdHJhbnNhY3Rpb24uIDwvc3Ryb25nPldlIG1heSB1c2UgeW91ciBwZXJzb25hbCBpbmZvcm1hdGlvbiBpbiB0aGUgZXZlbnQgd2UgdW5kZXJ0YWtlIG9yIGFyZSBpbnZvbHZlZCBpbiBvciBjb250ZW1wbGF0aW5nIGFueSBtZXJnZXIsIGFjcXVpc2l0aW9uLCByZW9yZ2FuaXphdGlvbiwgc2FsZSBvZiBhc3NldHMsIGJhbmtydXB0Y3ksIG9yIGluc29sdmVuY3kgZXZlbnQuPC9saT4NCjxsaSBzdHlsZT0ibWFyZ2luLXRvc狗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狗MTVweDsiIHR5cGU9ImNpcmNsZSI+PHN0cm9uZz5TZXJ2aWNlIHByb3ZpZGVycyBhbmQgcHJvZmVzc2lvbmFsIGFkdmlzb3JzPC9zdHJvbmc+LiBXZSBtYXkgZGlzY2xvc2UgeW91ciBpbmZvcm1hdGlvbiB0byB0aGlyZCBwYXJ0eSB2ZW5kb3JzIHdobyBwcm92aWRlIHNlcnZpY2VzIGluIHN1cHBvcnQgb2Ygb3VyIGJ1c2luZXNzIG9wZXJhdGlvbnMsIHN1Y2ggYXMgd2Vic2l0ZSBkZXZlbG9wbWVudCBhbmQgaG9zdGluZywgcGF5bWVudCBwcm9jZXNzaW5nLCByZWNydWl0bWVudCBhbmQgaGlyaW5nLCBtYXJrZXRpbmcgbWFuYWdlbWVudCwgc2VydmljZSBvcHRpbWl6YXRpb24sIHZlbmRvcnMgdGhhdCBmdWxmaWxsIG9yZGVycyBmb3IgZnVuZXJhbC1yZWxhdGVkIGl0ZW1zIHN1Y2ggYXMgZmxvd2VycywgYW5kIGRhdGEgYW5hbHl0aWNzLiBXZSBtYXkgYWxzbyBkaXNjbG9zZSB5b3VyIHBlcnNvbmFsIGluZm9ybWF0aW9uIHRvIHByb2Zlc3Npb25hbCBhZHZpc29ycyBzdWNoIGFzIG91ciBhdHRvcm5leXMsIGFjY291bnRhbnRzLCBhbmQgb3VycyBvciBFbmQgVXNlcnMmcnNxdW87IGluc3VyYW5jZSBwcm92aWRlcnMuPC9saT4NCjxsaSBzdHlsZT0ibWFyZ2luLXRvc狗MTVweDsiIHR5cGU9ImNpcmNsZSI+PHN0cm9uZz5QYXJ0aWVzIGludm9sdmVkIGluIGEgY29ycG9yYXRlIHRyYW5zYWN0aW9uPC9zdHJvbmc+LiBXZSBtYXkgZGlzY2xvc2UgeW91ciBpbmZvcm1hdGlvbiB0byByZWxldmFudCB0aGlyZCBwYXJ0aWVzIGluIHRoZSBldmVudCBvZiBhIGRpdmVzdGl0dXJlLCBtZXJnZXIsIGNvbnNvbGlkYXRpb24sIG9yIGFzc2V0IHNhbGUsIG9yIGluIHRoZSB1bmxpa2VseSBldmVudCBvZiBhIGJhbmtydXB0Y3kuPC9saT4NCjxsaSBzdHlsZT0ibWFyZ2luLXRvc狗MTVweDsiIHR5cGU9ImNpcmNsZSI+PHN0cm9uZz5MYXcgZW5mb3JjZW1lbnQgb3Igb3RoZXIgZ292ZXJubWVudGFsIGVudGl0aWVzPC9zdHJvbmc+LiBXZSBtYXkgZGlzY2xvc2UgeW91ciBpbmZvcm1hdGlvbiBpZiByZXF1aXJlZCB0byBkbyBzbyBieSBsYXcgb3IgaWYgd2UgYmVsaWV2ZSBpbiBnb29kIGZhaXRoIHRoYXQgc3VjaCBhY3Rpb24gaXMgbmVjZXNzYXJ5IHRvIGNvbXBseSB3aXRoIHRoZSBsYXcsIHByZXZlbnQgdW5sYXdmdWwgYWN0aXZpdHksIGRlZmVuZCBvdXIgcmlnaHRzLCBvciBtYWludGFpbiBzZWN1cml0eS48L2xpPg0KPGxpIHN0eWxlPSJtYXJnaW4tdG9wOiAxNXB4OyIgdHlwZT0iY2lyY2xlIj48c3Ryb25nPk90aGVyIHRoaXJkIHBhcnRpZXMgd2l0aCB5b3VyIGNvbnNlbnQ8L3N0cm9uZz4uIFdlIG1heSBkaXNjbG9zZSB5b3VyIGluZm9ybWF0aW9uIHRvIGFueSBvdGhlciB0aGlyZCBwYXJ0eSB3aGVyZSB5b3UgaGF2ZSBwcm92aWRlZCBjb25zZW50IHRvIHN1Y2ggZGlzY2xvc3VyZS48L2xpPg0KPC91bD4NCjxoMiBzdHlsZT0idGV4dC1hbGlnbjogbGVmdDsgZm9udC1zaXplOiAyMHB4OyBwYWRkaW5nLXRvc狗NjBweDsiPlNlY3VyaXR5LCBSZXRlbnRpb24gJmFtcDsgVHJhbnNmZXIgb2YgUGVyc29uYWwgSW5mb3JtYXRpb248L2gyPg0KPHAgc3R5bGU9InRleHQtYWxpZ246IGxlZnQ7IG1hcmdpbi1ib3R0b206IDE1cHg7Ij48YnIgLz5XZSBoYXZlIGltcGxlbWVudGVkIGFuZCBtYWludGFpbiBjb21tZXJjaWFsbHkgcmVhc29uYWJsZSBhbmQgYXBwcm9wcmlhdGUgdGVjaG5pY2FsIGFuZCBvcmdhbml6YXRpb25hbCBtZWFzdXJlcyBkZXNpZ25lZCB0byBwcm90ZWN0IHRoZSBjb25maWRlbnRpYWxpdHksIGludGVncml0eSwgYW5kIHNlY3VyaXR5IG9mIHlvdXIgcGVyc29uYWwgaW5mb3JtYXRpb24uIFBsZWFzZSBub3RlLCBob3dldmVyLCB0aGF0IG5vIHNlY3VyaXR5IG1lYXN1cmVzIGFyZSBwZXJmZWN0IG9yIGltcGVuZXRyYWJsZS4gV2UgdGhlcmVmb3JlIGNhbm5vdCBndWFyYW50eSBhbmQgZG8gbm90IHdhcnJhbnQgdGhlIGFic29sdXRlIHNlY3VyaXR5IG9mIHlvdXIgcGVyc29uYWwgaW5mb3JtYXRpb24uIFdlIHJldGFpbiB5b3VyIHBlcnNvbmFsIGluZm9ybWF0aW9uIGZvciBubyBsb25nZXIgdGhhbiByZWFzb25hYmx5IG5lY2Vzc2FyeSB0byBmdWxmaWxsIHRoZSBwdXJwb3NlcyBmb3Igd2hpY2ggd2UgY29sbGVjdGVkIGl0IG9yIHRvIGNvbXBseSB3aXRoIHRoZSBsYXcsIHByZXZlbnQgZnJhdWQsIGZhY2lsaXRhdGUgYW4gaW52ZXN0aWdhdGlvbiwgZGVmZW5kIGFnYWluc3QgbGVnYWwgY2xhaW1zLCBvciBleGVyY2lzZSBvdXIgbGVnYWwgcmlnaHRzLjxiciAvPjxiciAvPkRlcGVuZGluZyBvbiB5b3VyIGxvY2F0aW9uLCB0aGUgcGVyc29uYWwgaW5mb3JtYXRpb24gd2UgY29sbGVjdCBhYm91dCB5b3UgbWF5IGJlIHRyYW5zZmVycmVkIHRvIGEganVyaXNkaWN0aW9uIHRoYXQgZG9lcyBub3QgcHJvdmlkZSB0aGUgc2FtZSBsZXZlbCBvZiBwcm90ZWN0aW9uIG9mIHBlcnNvbmFsIGluZm9ybWF0aW9uIGFzIHRoZSBqdXJpc2RpY3Rpb24gaW4gd2hpY2ggeW91IHJlc2lkZS4gQW1vbmcgb3RoZXIgcGxhY2VzLCBwZXJzb25hbCBpbmZvcm1hdGlvbiBtYXkgYmUgdHJhbnNmZXJyZWQgdG8sIGFuZCBzdG9yZWQgaW4sIENhbmFkYSwgQXVzdHJhbGlhIGFuZCB0aGUgVW5pdGVkIFN0YXRlcy4gVHJhbnNmZXJzIGZyb20gdGhlIEV1cm9wZWFuIFVuaW9uIHRvIENhbmFkYSBhcmUgbWFkZSBwdXJzdWFudCB0byBFdXJvcGVhbiBDb21taXNzaW9uIERlY2lzaW9uIDIwMDIvMi9FQywgd2hpY2ggZGV0ZXJtaW5lZCB0aGF0IENhbmFkYSBpcyBjb25zaWRlcmVkIGFzIHByb3ZpZGluZyBhbiBhZGVxdWF0ZSBsZXZlbCBvZiBwcm90ZWN0aW9uIG9mIHBlcnNvbmFsIGluZm9ybWF0aW9uLjwvcD4NCjxoMiBzdHlsZT0idGV4dC1hbGlnbjogbGVmdDsgZm9udC1zaXplOiAyMHB4OyBwYWRkaW5nLXRvc狗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狗NDVweDsiPkNhbGlmb3JuaWEgUmVzaWRlbnRzPC9oMj4NCjxwIHN0eWxlPSJ0ZXh0LWFsaWduOiBsZWZ0OyBtYXJnaW4tYm90dG9tOiAxNXB4OyI+PGJyIC8+U3VwcGxlbWVudGFsIHRvIHRoZSBhYm92ZSwgdGhlIGZvbGxvd2luZyBhZGRpdGlvbmFsIGluZm9ybWF0aW9uIHBlcnRhaW5zIHRvIENhbGlmb3JuaWEgcmVzaWRlbnRzIG9ubHk6PGJyIC8+PGJyIC8+PHNwYW4gc3R5bGU9InRleHQtZGVjb3JhdGlvbjogdW5kZXJsaW5lOyI+PGVtPkNvbGxlY3Rpb24gYW5kIFVzZSBvZiBQZXJzb25hbCBJbmZvcm1hdGlvbjwvZW0+PC9zcGFuPjwvcD4NCjx1bCBzdHlsZT0idGV4dC1hbGlnbjogbGVmdDsgcGFkZGluZy1sZWZ0OiAzMHB4OyI+DQo8bGkgdHlwZT0iY2lyY2xlIj5DYXRlZ29yaWVzIG9mIHBlcnNvbmFsIGluZm9ybWF0aW9uIGNvbGxlY3RlZCBhYm91dCBDYWxpZm9ybmlhIHJlc2lkZW50cyBpbiB0aGUgcGFzdCB0d2VsdmUgbW9udGhzIGluY2x1ZGUgaWRlbnRpZmllcnMsIG90aGVyIGlkZW50aWZ5aW5nIGluZm9ybWF0aW9uLCBjaGFyYWN0ZXJpc3RpY3Mgb2YgcHJvdGVjdGVkIGNsYXNzLCBjb21tZXJjaWFsIGluZm9ybWF0aW9uLCBJbnRlcm5ldCBvciBvdGhlciBlbGVjdHJvbmljIG5ldHdvcmsgYWN0aXZpdHkgaW5mb3JtYXRpb24sIHByb2Zlc3Npb25hbCBvciBlbXBsb3ltZW50LXJlbGF0ZWQgaW5mb3JtYXRpb24sIGVkdWNhdGlvbiBpbmZvcm1hdGlvbiwgYW5kIGluZmVyZW5jZXMgZHJhd24gZnJvbSBzdWNoIGluZm9ybWF0aW9uLiBGb3IgZXhhbXBsZXMgb2Ygc3BlY2lmaWMgcGllY2VzIG9mIHBlcnNvbmFsIGluZm9ybWF0aW9uIGNvbGxlY3RlZCwgcGxlYXNlIHNlZSB0aGUgJmxkcXVvO1BlcnNvbmFsIEluZm9ybWF0aW9uIFdlIENvbGxlY3QmcmRxdW87IHNlY3Rpb24gYWJvdmUuPC9saT4NCjxsaSBzdHlsZT0ibWFyZ2luLXRvc狗MTVweDsiIHR5cGU9ImNpcmNsZSI+Q2F0ZWdvcmllcyBvZiBwZXJzb25hbCBpbmZvcm1hdGlvbiBkaXNjbG9zZWQgZm9yIGEgYnVzaW5lc3MgcHVycG9zZSBhYm91dCBDYWxpZm9ybmlhIHJlc2lkZW50cyBpbiB0aGUgcGFzdCB0d2VsdmUgbW9udGhzIGluY2x1ZGUgaWRlbnRpZmllcnMsIG90aGVyIGlkZW50aWZ5aW5nIGluZm9ybWF0aW9uLCBjaGFyYWN0ZXJpc3RpY3Mgb2YgcHJvdGVjdGVkIGNsYXNzLCBjb21tZXJjaWFsIGluZm9ybWF0aW9uLCBJbnRlcm5ldCBvciBvdGhlciBlbGVjdHJvbmljIG5ldHdvcmsgYWN0aXZpdHkgaW5mb3JtYXRpb24sIHByb2Zlc3Npb25hbCBvciBlbXBsb3ltZW50LXJlbGF0ZWQgaW5mb3JtYXRpb24sIGFuZCBlZHVjYXRpb24gaW5mb3JtYXRpb24uPC9saT4NCjxsaSBzdHlsZT0ibWFyZ2luLXRvc狗MTVweDsiIHR5cGU9ImNpcmNsZSI+V2UgZG8gbm90IHNlbGwgcGVyc29uYWwgaW5mb3JtYXRpb24sIG5vciBkbyB3ZSBzaGFyZSBwZXJzb25hbCBpbmZvcm1hdGlvbiB3aXRoIHRoaXJkIHBhcnRpZXMgZm9yIHRob3NlIHRoaXJkIHBhcnRpZXMmcnNxdW87IGRpcmVjdCBtYXJrZXRpbmcgcHVycG9zZXMuPC9saT4NCjwvdWw+DQo8cCBzdHlsZT0idGV4dC1hbGlnbjogbGVmdDsgbWFyZ2luOiA1cHggMCAxNXB4IDA7Ij48YnIgLz48c3BhbiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOiB1bmRlcmxpbmU7Ij48ZW0+WW91ciBDYWxpZm9ybmlhIFByaXZhY3kgUmlnaHRzPC9lbT48L3NwYW4+PGJyIC8+QXMgYSBDYWxpZm9ybmlhIHJlc2lkZW50LCB5b3UgaGF2ZSB0aGUgZm9sbG93aW5nIHJpZ2h0cyB3aXRoIHJlc3BlY3QgdG8geW91ciBwZXJzb25hbCBpbmZvcm1hdGlvbjo8L3A+DQo8dWwgc3R5bGU9InRleHQtYWxpZ246IGxlZnQ7IHBhZGRpbmctbGVmd狗MzBweDsiPg0KPGxpIHR5cGU9ImNpcmNsZSI+WW91IGhhdmUgdGhlIHJpZ2h0IHRvIHJlcXVlc3QgdG8ga25vdyBhYm91dCBwZXJzb25hbCBpbmZvcm1hdGlvbiBjb2xsZWN0ZWQsIGRpc2Nsb3NlZCwgb3Igc29sZC48L2xpPg0KPGxpIHN0eWxlPSJtYXJnaW4tdG9wOiAxNXB4OyIgdHlwZT0iY2lyY2xlIj5Zb3UgaGF2ZSB0aGUgcmlnaHQgdG8gcmVxdWVzdCB0aGUgZGVsZXRpb24gb2YgcGVyc29uYWwgaW5mb3JtYXRpb24uPC9saT4NCjxsaSBzdHlsZT0ibWFyZ2luLXRvc狗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

PGgxIHN0eWxlPSJ0ZXh0LWFsaWduOiBsZWZ0OyBmb250LXNpemU6IDI1cHg7Ij5GcmF6ZXIgQ29uc3VsdGFudHMgVGVybXMgb2YgVXNlPC9oMT4NCjxwIHN0eWxlPSJ0ZXh0LWFsaWduOiBsZWZ0OyBtYXJnaW4tYm90dG9tOiAxNXB4OyI+PGVtPkxhc3QgVXBkYXRlZ狗MDkvMDQvMjAyMDwvZW0+PGJyIC8+PGJyIC8+VGhlc2UgVGVybXMgb2YgVXNlLCB0b2dldGhlciB3aXRoIEZyYXplciBDb25zdWx0YW50cycgPGEgaHJlZj0iaHR0cHM6Ly9mcmF6ZXJjb25zdWx0YW50cy5jb20vcHJpdmFjeS1wb2xpY3kvIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5Qcml2YWN5IFBvbGljeTwvYT4sIChjb2xsZWN0aXZlbHksIHRoZSAiVGVybXMiKSBzZXQgZm9ydGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIHRoYXQgYXBwbHkgdG8geW91ciBhY2Nlc3MgYW5kIHVzZSBvZiB0aGUgd2Vic2l0ZSBvZiBGcmF6ZXIgQ29uc3VsdGFudHMgTExDIChodHRwczovL3d3dy5mcmF6ZXJjb25zdWx0YW50cy5jb20vKSAoIkZyYXplciIgIndlIiBvciAidXMiKSBhbmQgYXNzb2NpYXRlZCBzZXJ2aWNlcywgaW5jbHVkaW5nIEZyYXplciBzZXJ2aWNlcyB0aGF0IGFyZSBhdmFpbGFibGUgdGhyb3VnaCB0aGUgd2Vic2l0ZXMgb2Ygb3VyIGNsaWVudCBmdW5lcmFsIGhvbWVzIGFuZCBvdGhlciBmdW5lcmFsIHByb2Zlc3Npb25hbHMgKHRvZ2V0aGVyLCB0aGUgIlNpdGVzIiksIHdoZXRoZXIgYXMgYSBjbGllbnQsIGVuZCB1c2VyIG9yIGN1c3RvbWVyIG9mIGEgY2xpZW50LCBvciBvdGhlcndpc2UuICJGcmF6ZXIiIGluY2x1ZGVzIGFsbCBvZmZpY2VycywgZGlyZWN0b3JzLCBlbXBsb3llZXMsIGNvbnN1bHRhbnRzLCBhZmZpbGlhdGVzLCBzdWJzaWRpYXJpZXMsIGFuZCBhZ2VudHMuIFRoZSBUZXJtcyBjb25zdGl0dXRlIGEgbGVnYWxseSBiaW5kaW5nIGFncmVlbWVudCBiZXR3ZWVuIHlvdSwgd2hldGhlciBwZXJzb25hbGx5IG9yIG9uIGJlaGFsZiBvZiBhbiBlbnRpdHkgKCJ5b3UiKSBhbmQgRnJhemVyIGNvbmNlcm5pbmcgeW91ciBhY2Nlc3MgdG8gYW5kIHVzZSBvZiB0aGUgU2l0ZXMuPGJyIC8+PGJyIC8+QnkgdXNpbmcgb3IgYWNjZXNzaW5nIHRoZSBTaXRlcywgeW91IGFncmVlIHRvIHRoZXNlIFRlcm1zLCBhcyBtYXkgYmUgdXBkYXRlZCBmcm9tIHRpbWUgdG8gdGltZSBpbiBhY2NvcmRhbmNlIHdpdGggU2VjdGlvbiA5IGJlbG93LjwvcD4NCjxvbCBzdHlsZT0idGV4dC1hbGlnbjogbGVmdDsgcGFkZGluZy1sZWZ0OiAzMHB4OyI+DQo8bGkgdHlwZT0iMSI+PHN0cm9uZz5BY2NvdW50IFNlY3VyaXR5Ljwvc3Ryb25nPiBUbyB1c2UgdGhlIFNpdGVzIHlvdSBtdXN0IChpKSBiZSBhdCBsZWFzdCBlaWdodGVlbiAoMTgpIHllYXJzIG9mIGFnZTsgKGlpKSBoYXZlIG5vdCBwcmV2aW91c2x5IGJlZW4gc3VzcGVuZGVkIG9yIHJlbW92ZWQgZnJvbSB0aGUgU2l0ZXM7IGFuZCAoaWlpKSByZWdpc3RlciBmb3IgYW5kIHVzZSB0aGUgU2l0ZXMgaW4gY29tcGxpYW5jZSB3aXRoIGFueSBhbmQgYWxsIGFwcGxpY2FibGUgbGF3cyBhbmQgcmVndWxhdGlvbnMuPC9saT4NCjxsaSBzdHlsZT0ibWFyZ2luLXRvc狗MTVweDsiIHR5cGU9IjEiPjxzdHJvbmc+QWNjb3VudCBSZWdpc3RyYXRpb24uPC9zdHJvbmc+IFRvIGFjY2VzcyBzb21lIGZlYXR1cmVzIG9mIHRoZSBTaXRlcywgeW91IG1heSBiZSByZXF1aXJlZCB0byByZWdpc3RlciBmb3IgYW4gYWNjb3VudC4gV2hlbiB5b3UgcmVnaXN0ZXIgZm9yIGFuIGFjY291bnQsIHdlIG1heSBhc2sgeW91IHRvIGdpdmUgdXMgY2VydGFpbiBpZGVudGlmeWluZyBpbmZvcm1hdGlvbiBhYm91dCB5b3Vyc2VsZiwgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZCB0byB5b3VyIGVtYWlsIGFkZHJlc3MgYW5kIG90aGVyIGNvbnRhY3QgaW5mb3JtYXRpb24sIGFuZCB0byBjcmVhdGUgYSB1c2VyIG5hbWUgYW5kIHBhc3N3b3JkICgiUmVnaXN0cmF0aW9uIEluZm9ybWF0aW9uIikuIFdoZW4gcmVnaXN0ZXJpbmcgZm9yIGFuZCBtYWludGFpbmluZyBhbiBhY2NvdW50LCB5b3UgYWdyZWUgdG8gcHJvdmlkZSB0cnVlLCBhY2N1cmF0ZSwgY3VycmVudCwgYW5kIGNvbXBsZXRlIGluZm9ybWF0aW9uIGFib3V0IHlvdXJzZWxmLiBZb3UgYWxzbyBhZ3JlZSBub3QgdG8gaW1wZXJzb25hdGUgYW55b25lLCBtaXNyZXByZXNlbnQgYW55IGFmZmlsaWF0aW9uIHdpdGggYW55b25lIGVsc2UsIHVzZSBmYWxzZSBpbmZvcm1hdGlvbiwgb3Igb3RoZXJ3aXNlIGNvbmNlYWwgeW91ciBpZGVudGl0eSBmcm9tIEZyYXplciBmb3IgYW55IHB1cnBvc2UuIFlvdSBhcmUgc29sZWx5IHJlc3BvbnNpYmxlIGZvciBtYWludGFpbmluZyB0aGUgY29uZmlkZW50aWFsaXR5IGFuZCBzZWN1cml0eSBvZiB5b3VyIHBhc3N3b3JkIGFuZCBvdGhlciBSZWdpc3RyYXRpb24gSW5mb3JtYXRpb24uIEZvciB5b3VyIHByb3RlY3Rpb24gYW5kIHRoZSBwcm90ZWN0aW9uIG9mIG90aGVyIHVzZXJzLCB3ZSBhc2sgeW91IG5vdCB0byBzaGFyZSB5b3VyIFJlZ2lzdHJhdGlvbiBJbmZvcm1hdGlvbiB3aXRoIGFueW9uZSBlbHNlLiBJZiB5b3UgZG8gc2hhcmUgdGhpcyBpbmZvcm1hdGlvbiB3aXRoIGFueW9uZSwgd2Ugd2lsbCBjb25zaWRlciB0aGVpciBhY3Rpdml0aWVzIHRvIGhhdmUgYmVlbiBhdXRob3JpemVkIGJ5IHlvdS4gSWYgeW91IGhhdmUgcmVhc29uIHRvIGJlbGlldmUgdGhhdCB5b3VyIGFjY291bnQgaXMgbm8gbG9uZ2VyIHNlY3VyZSwgeW91IG11c3QgaW1tZWRpYXRlbHkgbm90aWZ5IHVzIGF0IDxhIGhyZWY9Im1haWx0bzpoZWxwQGZyYXplcmNvbnN1bHRhbnRzLmNvbSI+aGVscEBmcmF6ZXJjb25zdWx0YW50cy5jb208L2E+LjwvbGk+DQo8bGkgc3R5bGU9Im1hcmdpbi10b3A6IDE1cHg7IiB0eXBlPSIxIj48c3Ryb25nPlByb2hpYml0ZWQuPC9zdHJvbmc+IFlvdSBhZ3JlZSBub3QgdG86DQo8b2wgc3R5bGU9InBhZGRpbmctbGVmd狗MjBweDsiPg0KPGxpIHN0eWxlPSJtYXJnaW4tdG9wOiA1cHg7IiB0eXBlPSJBIj5Vc2UgdGhlIFNpdGVzIGZvciBhbnkgaWxsZWdhbCBwdXJwb3NlLCBvciBpbiB2aW9sYXRpb24gb2YgYW55IGxvY2FsLCBzdGF0ZSwgbmF0aW9uYWwsIG9yIGludGVybmF0aW9uYWwgbGF3OzwvbGk+DQo8bGkgc3R5bGU9Im1hcmdpbi10b3A6IDVweDsiIHR5cGU9IkEiPlZpb2xhdGUgb3IgZW5jb3VyYWdlIG90aGVycyB0byB2aW9sYXRlIHRoZSByaWdodHMgb2YgdGhpcmQgcGFydGllcywgaW5jbHVkaW5nIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHM7PC9saT4NCjxsaSBzdHlsZT0ibWFyZ2luLXRvc狗NXB4OyIgdHlwZT0iQSI+UG9zdCwgdXBsb2FkLCBvciBkaXN0cmlidXRlIGFueSBjb250ZW50IHRoYXQgaXMgdW5sYXdmdWwsIGRlZmFtYXRvcnksIGxpYmVsb3VzLCBpbmFjY3VyYXRlLCBvciB0aGF0IGEgcmVhc29uYWJsZSBwZXJzb24gY291bGQgZGVlbSB0byBiZSBvYmplY3Rpb25hYmxlLCBwcm9mYW5lLCBpbmRlY2VudCwgcG9ybm9ncmFwaGljLCBoYXJhc3NpbmcsIHRocmVhdGVuaW5nLCBoYXRlZnVsLCBvciBvdGhlcndpc2UgaW5hcHByb3ByaWF0ZTs8L2xpPg0KPGxpIHN0eWxlPSJtYXJnaW4tdG9wOiA1cHg7IiB0eXBlPSJBIj5JbnRlcmZlcmUgaW4gYW55IHdheSB3aXRoIHNlY3VyaXR5LXJlbGF0ZWQgZmVhdHVyZXMgb2YgdGhlIFNpdGVzOzwvbGk+DQo8bGkgc3R5bGU9Im1hcmdpbi10b3A6IDVweDsiIHR5cGU9IkEiPkludGVyZmVyZSB3aXRoIHRoZSBvcGVyYXRpb24gb3IgYW55IHVzZXIncyBlbmpveW1lbnQgb2YgdGhlIFNpdGVzLCBpbmNsdWRpbmcgYnkgdXBsb2FkaW5nIG9yIG90aGVyd2lzZSBkaXNzZW1pbmF0aW5nIHZpcnVzZXMsIGFkd2FyZSwgc3B5d2FyZSwgd29ybXMsIG9yIG90aGVyIG1hbGljaW91cyBjb2RlLCBtYWtpbmcgdW5zb2xpY2l0ZWQgb2ZmZXJzIG9yIGFkdmVydGlzZW1lbnRzIHRvIG90aGVyIHVzZXJzLCBvciBhdHRlbXB0aW5nIHRvIGNvbGxlY3QgcGVyc29uYWwgaW5mb3JtYXRpb24gYWJvdXQgdXNlcnMgb3IgdGhpcmQgcGFydGllcyB3aXRob3V0IHRoZWlyIGNvbnNlbnQ7PC9saT4NCjxsaSBzdHlsZT0ibWFyZ2luLXRvc狗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狗MTVweDsiIHR5cGU9IjEiPjxzdHJvbmc+VXNlciBDb250ZW50Ljwvc3Ryb25nPiBZb3UgcmVwcmVzZW50IGFuZCB3YXJyYW50IHRoYXQgeW91IG93biBvciBvdGhlcndpc2UgaGF2ZSB0aGUgcmlnaHQgdG8gdXNlIGFueSBjb250ZW50IHlvdSBwb3N0IHRvIHRoZSBTaXRlcy4gSWYgeW91IGJlbGlldmUgdGhhdCB5b3VyIGNvbnRlbnQgaGFzIGJlZW4gdXNlZCBpbiBhIHdheSB0aGF0IGNvbnN0aXR1dGVzIGNvcHlyaWdodCBpbmZyaW5nZW1lbnQsIHlvdSBtYXkgY29udGFjdCBvdXIgRGVzaWduYXRlZCBBZ2VudDo8L2xpPg0KPC9vbD4NCjxwIHN0eWxlPSJtYXJnaW4tYm90dG9tOiAwOyI+PGJyIC8+QWRhbSBIb3ZleTxiciAvPkZyYXplciBDb25zdWx0YW50cywgTExDPGJyIC8+MjUwMSBQYXJtZW50ZXIgU3RyZWV0IC0gU3VpdGUgMzAwQTxiciAvPk1pZGRsZXRvbiwgV0kgNTM1NjI8YnIgLz5QaG9uZTogPGEgaHJlZj0idGVsOjYwODU4ODg1MjIiPig2MDgpIDU4OC04NTIyPC9hPjxiciAvPkZhe狗KDg2NikgNDQ3LTAzMTE8YnIgLz5FbWFpb狗PGEgaHJlZj0ibWFpbHRvOmFkYW1AZnJhemVyY29uc3VsdGFudHMuY29tIj5hZGFtQGZyYXplcmNvbnN1bHRhbnRzLmNvbTwvYT48L3A+DQo8cCBzdHlsZT0idGV4dC1hbGlnbjogbGVmdDsiPjxiciAvPllvdSBtdXN0IHByb3ZpZGUgdGhlIGZvbGxvd2luZyBpbmZvcm1hdGlvbjogYW4gZWxlY3Ryb25pYyBvciBwaHlzaWNhbCBzaWduYXR1cmUgb2YgdGhlIGNvcHlyaWdodCBvd25lciBvciB0aGUgcGVyc29uIGF1dGhvcml6ZWQgdG8gYWN0IG9uIGJlaGFsZiBvZiB0aGUgY29weXJpZ2h0IG93bmVyOyBhIGRlc2NyaXB0aW9uIG9mIHRoZSBjb3B5cmlnaHRlZCB3b3JrIHRoYXQgeW91IGNsYWltIGhhcyBiZWVuIGluZnJpbmdlZDsgYSBkZXNjcmlwdGlvbiBvZiB3aGVyZSB0aGUgbWF0ZXJpYWwgdGhhdCB5b3UgY2xhaW0gaXMgaW5mcmluZ2luZyBpcyBsb2NhdGVkOyB5b3VyIGFkZHJlc3MsIHRlbGVwaG9uZSBudW1iZXIsIGFuZCBlbWFpbCBhZGRyZXNzOyBhIHdyaXR0ZW4gc3RhdGVtZW50IHRoYXQgeW91IGhhdmUgYSBnb29kIGZhaXRoIGJlbGllZiB0aGF0IHRoZSBkaXNwdXRlZCB1c2UgaXMgbm90IGF1dGhvcml6ZWQgYnkgdGhlIGNvcHlyaWdodCBvd25lciwgaXRzIGFnZW50LCBvciB0aGUgbGF3OyBhIHN0YXRlbWVudCBieSB5b3UsIG1hZGUgdW5kZXIgcGVuYWx0eSBvZiBwZXJqdXJ5LCB0aGF0IHRoZSBhYm92ZSBpbmZvcm1hdGlvbiBpbiB5b3VyIG5vdGljZSBpcyBhY2N1cmF0ZSBhbmQgdGhhdCB5b3UgYXJlIHRoZSBjb3B5cmlnaHQgb3duZXIgb3IgYXV0aG9yaXplZCB0byBhY3Qgb24gdGhlIGNvcHlyaWdodCBvd25lcidzIGJlaGFsZi4gRnJhemVyIGhhcyBhZG9wdGVkIGFuZCBpbXBsZW1lbnRzIGEgcG9saWN5IHRoYXQgcHJvdmlkZXMgZm9yIHRlcm1pbmF0aW9uIGluIGFwcHJvcHJpYXRlIGNpcmN1bXN0YW5jZXMgb2YgYWNjb3VudHMgb2YgdXNlcnMgd2hvIHJlcGVhdGVkbHkgaW5mcmluZ2UgY29weXJpZ2h0IG9yIG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMgb2YgRnJhemVyIG9yIG90aGVycy48L3A+DQo8b2wgc3R5bGU9InRleHQtYWxpZ246IGxlZnQ7IHBhZGRpbmctbGVmd狗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狗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狗MTVweDsiIHR5cGU9IjEiPjxzdHJvbmc+R2VuZXJhbC48L3N0cm9uZz4NCjxvbCBzdHlsZT0icGFkZGluZy1sZWZ0OiAyMHB4OyI+DQo8bGkgc3R5bGU9Im1hcmdpbi10b3A6IDVweDsiIHR5cGU9IkEiPjx1PkVudGlyZSBBZ3JlZW1lbnQ8L3U+LiBUaGVzZSBUZXJtcyBjb25zdGl0dXRlIHRoZSBlbnRpcmUgYW5kIGV4Y2x1c2l2ZSB1bmRlcnN0YW5kaW5nIGFuZCBhZ3JlZW1lbnQgYmV0d2VlbiB5b3UgYW5kIEZyYXplciByZWdhcmRpbmcgeW91ciB1c2Ugb2YgYW5kIGFjY2VzcyB0byB0aGUgU2l0ZXMsIGFuZCBleGNlcHQgYXMgZXhwcmVzc2x5IHBlcm1pdHRlZCBhYm92ZSBtYXkgb25seSBiZSBhbWVuZGVkIGJ5IGEgd3JpdHRlbiBhZ3JlZW1lbnQgc2lnbmVkIGJ5IGF1dGhvcml6ZWQgcmVwcmVzZW50YXRpdmVzIG9mIHRoZSBwYXJ0aWVzLjwvbGk+DQo8bGkgc3R5bGU9Im1hcmdpbi10b3A6IDVweDsiIHR5cGU9IkEiPjx1Pk5vIFdhaXZlcjwvdT4uIFRoZSBmYWlsdXJlIHRvIHJlcXVpcmUgcGVyZm9ybWFuY2Ugb2YgYW55IHByb3Zpc2lvbiBzaGFsbCBub3QgYWZmZWN0IG91ciByaWdodCB0byByZXF1aXJlIHBlcmZvcm1hbmNlIGF0IGFueSB0aW1lIHRoZXJlYWZ0ZXIsIG5vciBzaGFsbCBhIHdhaXZlciBvZiBhbnkgYnJlYWNoIG9yIGRlZmF1bHQgb2YgdGhlIFRlcm1zIGNvbnN0aXR1dGUgYSB3YWl2ZXIgb2YgYW55IHN1YnNlcXVlbnQgYnJlYWNoIG9yIGRlZmF1bHQgb3IgYSB3YWl2ZXIgb2YgdGhlIHByb3Zpc2lvbiBpdHNlbGYuPC9saT4NCjxsaSBzdHlsZT0ibWFyZ2luLXRvc狗NXB4OyIgdHlwZT0iQSI+PHU+UGFyYWdyYXBoIEhlYWRlcnM8L3U+LiBVc2Ugb2YgcGFyYWdyYXBoIGhlYWRlcnMgaW4gdGhlIFRlcm1zIGlzIGZvciBjb252ZW5pZW5jZSBvbmx5IGFuZCBzaGFsbCBub3QgaGF2ZSBhbnkgaW1wYWN0IG9uIHRoZSBpbnRlcnByZXRhdGlvbiBvZiBwYXJ0aWN1bGFyIHByb3Zpc2lvbnMuPC9saT4NCjxsaSBzdHlsZT0ibWFyZ2luLXRvc狗NXB4OyIgdHlwZT0iQSI+PHU+U2V2ZXJhYmlsaXR5PC91Pi4gSW4gdGhlIGV2ZW50IHRoYXQgYW55IHBhcnQgb2YgdGhlIFRlcm1zIGlzIGhlbGQgdG8gYmUgaW52YWxpZCBvciB1bmVuZm9yY2VhYmxlLCB0aGUgdW5lbmZvcmNlYWJsZSBwYXJ0IHNoYWxsIGJlIGdpdmVuIGVmZmVjdCB0byB0aGUgZ3JlYXRlc3QgZXh0ZW50IHBvc3NpYmxlIGFuZCB0aGUgcmVtYWluaW5nIHBhcnRzIHdpbGwgcmVtYWluIGluIGZ1bGwgZm9yY2UgYW5kIGVmZmVjdC48L2xpPg0KPC9vbD4NCjwvbGk+DQo8bGkgc3R5bGU9Im1hcmdpbi10b3A6IDE1cHg7IiB0eXBlPSIxIj48c3Ryb25nPk5vdGljZSB0byBDYWxpZm9ybmlhIFJlc2lkZW50cy48L3N0cm9uZz4gVW5kZXIgQ2FsaWZvcm5pYSBDaXZpbCBDb2RlIFNlY3Rpb24gMTc4OS4zLCB5b3UgbWF5IGNvbnRhY3QgdGhlIENvbXBsYWludCBBc3Npc3RhbmNlIFVuaXQgb2YgdGhlIERpdmlzaW9uIG9mIENvbnN1bWVyIFNlcnZpY2VzIG9mIHRoZSBDYWxpZm9ybmlhIERlcGFydG1lbnQgb2YgQ29uc3VtZXIgQWZmYWlycyBpbiB3cml0aW5nIGF0IDE2MjUgTi4gTWFya2V0IEJsdmQuLCBTdWl0ZSBTLTIwMiwgU2FjcmFtZW50bywgQ2FsaWZvcm5pYSA5NTgzNCwgb3IgYnkgdGVsZXBob25lIGF0ICg4MDApIDk1Mi01MjEwIGluIG9yZGVyIHRvIHJlc29sdmUgYSBjb21wbGFpbnQgcmVnYXJkaW5nIHRoZSBzZXJ2aWNlIG9yIHRvIHJlY2VpdmUgZnVydGhlciBpbmZvcm1hdGlvbiByZWdhcmRpbmcgdXNlIG9mIHRoZSBzZXJ2aWNlLjwvbGk+DQo8L29sPg==