{"id":58223,"date":"2021-10-09T12:52:47","date_gmt":"2021-10-09T10:52:47","guid":{"rendered":"https:\/\/tissi.de\/protection-des-donnees\/"},"modified":"2026-06-25T04:48:20","modified_gmt":"2026-06-25T02:48:20","slug":"protection-des-donnees","status":"publish","type":"page","link":"https:\/\/tissi.de\/fr\/protection-des-donnees\/","title":{"rendered":"Protection des donn\u00e9es"},"content":{"rendered":"<div class=\"wpb-content-wrapper\"><p>[vc_section][vc_row][vc_column width=&#8221;1\/1&#8243;][vc_raw_html]PGRpdiBjbGFzcz0iam1kc25pcHBldCIgZGF0YS1qbWQtc25pcHBldC12ZXJzaW9uPSIzIiBzdHlsZT0icG9zaXRpb246IHJlbGF0aXZlO21pbi1oZWlnaHQ6IDgwdmg7Ij4KPGRpdiBpZD0iam1kd3JhcHBlci0xNzIyNTAzMDYwNDMyIiBkYXRhLWptZHdyYXBwZXI9IjE3MjI1MDMwNjA0MzIiPgo8c3R5bGU+CiAgICAgICAgICAgICNqbWRjb250ZW50IGgxLCAjam1kY29udGVudCBoMiwgI2ptZGNvbnRlbnQgaDMsICNqbWRjb250ZW50IGg0LCAjam1kY29udGVudCBoNSwgI2ptZGNvbnRlbnQgaDYgewogICAgICAgICAgICAgICAgbWFyZ2luOiAxLjVlbSAwIDFlbSAwOwogICAgICAgICAgICB9CgogICAgICAgICAgICAjam1kY29udGVudCB7CiAgICAgICAgICAgICAgICBmb250LXNpemU6IDE0cHg7CiAgICAgICAgICAgICAgICBsaW5lLWhlaWdodDogMS41OwogICAgICAgICAgICAgICAgdGV4dC1hbGlnbjogbGVmdDsKICAgICAgICAgICAgfQoKICAgICAgICAgICAgI2ptZGNvbnRlbnQgYSB7CiAgICAgICAgICAgICAgICB3b3JkLWJyZWFrOiBicmVhay13b3JkOwogICAgICAgICAgICB9CgogICAgICAgICAgICAjam1kY29udGVudCBjb2RlIHsKICAgICAgICAgICAgICAgIGJhY2tncm91bmQtY29sb3I6ICNmNWY1ZjU7CiAgICAgICAgICAgICAgICBjb2xvcjogI2JkNDE0NzsKICAgICAgICAgICAgICAgIGJveC1zaGFkb3c6IDAgMnB4IDFweCAtMXB4IHJnYmEoMCwwLDAsLjIpLCAwIDFweCAxcHggMCByZ2JhKDAsMCwwLC4xNCksIDAgMXB4IDNweCAwIHJnYmEoMCwwLDAsLjEyKTsKICAgICAgICAgICAgICAgIGRpc3BsYXk6IGlubGluZS1ibG9jazsKICAgICAgICAgICAgICAgIGJvcmRlci1yYWRpdXM6IDNweDsKICAgICAgICAgICAgICAgIHdoaXRlLXNwYWNlOiBwcmUtd3JhcDsKICAgICAgICAgICAgICAgIGZvbnQtc2l6ZTogODUlOwogICAgICAgICAgICAgICAgZm9udC13ZWlnaHQ6IDkwMDsKICAgICAgICAgICAgfQoKICAgICAgICAgICAgI2ptZGNvbnRlbnQgY29kZTphZnRlciwgI2ptZGNvbnRlbnQgY29kZTpiZWZvcmUgewogICAgICAgICAgICAgICAgY29udGVudDogIlxBMCI7CiAgICAgICAgICAgICAgICBsZXR0ZXItc3BhY2luZzogLTFweDsKICAgICAgICAgICAgfQoKICAgICAgICAgICAgI2ptZGNvbnRlbnQgdGFibGUgewogICAgICAgICAgICAgICAgYm9yZGVyOiBzb2xpZCAxcHggI0VFRUVFRTsKICAgICAgICAgICAgICAgIGJvcmRlci1jb2xsYXBzZTogY29sbGFwc2U7CiAgICAgICAgICAgICAgICBib3JkZXItc3BhY2luZzogMDsKICAgICAgICAgICAgICAgIGZvbnQtc2l6ZTogMC45ZW07CiAgICAgICAgICAgICAgICBsaW5lLWhlaWdodDogbm9ybWFsOwogICAgICAgICAgICB9CgogICAgICAgICAgICAjam1kY29udGVudCB0YWJsZSB0aGVhZCB0aCB7CiAgICAgICAgICAgICAgICBiYWNrZ3JvdW5kLWNvbG9yOiAjRUZFRkVGOwogICAgICAgICAgICAgICAgcGFkZGluZzogMTBweDsKICAgICAgICAgICAgICAgIHRleHQtYWxpZ246IGxlZnQ7CiAgICAgICAgICAgICAgICBjb2xvcjogYmxhY2s7CiAgICAgICAgICAgICAgICBtYXJnaW46IHJldmVydDsKICAgICAgICAgICAgICAgIHdpZHRoOiByZXZlcnQ7CiAgICAgICAgICAgICAgICBoZWlnaHQ6IHJldmVydDsKICAgICAgICAgICAgfQoKICAgICAgICAgICAgI2ptZGNvbnRlbnQgdGFibGUgdGJvZHkgdGQgewogICAgICAgICAgICAgICAgYm9yZGVyOiBzb2xpZCAxcHggI0VFRUVFRTsKICAgICAgICAgICAgICAgIHBhZGRpbmc6IDEwcHg7CiAgICAgICAgICAgIH0KCiAgICAgICAgICAgICNqbWRjb250ZW50IC5jYW5jZWxsYXRpb24tcG9saWN5LCAjam1kY29udGVudCAuam1kLWJvcmRlcmVkIHsKICAgICAgICAgICAgICAgIGJvcmRlcjogc29saWQgMXB4OwogICAgICAgICAgICAgICAgcGFkZGluZzogMGVtIDFlbTsKICAgICAgICAgICAgfQoKICAgICAgICAgICAgI2ptZGNvbnRlbnQgb2wgewogICAgICAgICAgICAgIGNvdW50ZXItcmVzZXQ6IGl0ZW07CiAgICAgICAgICAgIH0KCiAgICAgICAgICAgICNqbWRjb250ZW50IG9sID4gbGkgewogICAgICAgICAgICAgIGRpc3BsYXk6IGJsb2NrOwogICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAjam1kY29udGVudCBsaSB7CiAgICAgICAgICAgICBsaXN0LXN0eWxlLXBvc2l0aW9uOiBvdXRzaWRlICFpbXBvcnRhbnQ7CiAgICAgICAgICAgIH0KCiAgICAgICAgICAgICNqbWRjb250ZW50IG9sID4gbGkgPio6Zmlyc3QtY2hpbGQ6YmVmb3JlIHsKICAgICAgICAgICAgICBjb250ZW50OiBjb3VudGVycyhpdGVtLCAiLiIpICIuICI7CiAgICAgICAgICAgICAgY291bnRlci1pbmNyZW1lbnQ6IGl0ZW0KICAgICAgICAgICAgfQoKICAgICAgICAgICAgQG1lZGlhIChtYXgtd2lkdGg6IDE2MDBweCkgewoKICAgICAgICAgICAgICAgICNqbWRjb250ZW50IHRhYmxlLCAjam1kY29udGVudCB0aGVhZCwgI2ptZGNvbnRlbnQgdGJvZHksICNqbWRjb250ZW50IHRmb290LAogICAgICAgICAgICAgICAgI2ptZGNvbnRlbnQgdHIsICNqbWRjb250ZW50IHRoLCAjam1kY29udGVudCB0ZCB7CiAgICAgICAgICAgICAgICAgICAgZGlzcGxheTogYmxvY2s7CiAgICAgICAgICAgICAgICB9CgogICAgICAgICAgICAgICAgI2ptZGNvbnRlbnQgdGhlYWQgdHIsICNqbWRjb250ZW50IHRmb290IHRyID4gdGggewogICAgICAgICAgICAgICAgICAgIGRpc3BsYXk6IG5vbmU7CiAgICAgICAgICAgICAgICB9CgogICAgICAgICAgICAgICAgI2ptZGNvbnRlbnQgdHIgewogICAgICAgICAgICAgICAgICAgIGJvcmRlcjogMXB4IHNvbGlkICNjY2M7CiAgICAgICAgICAgICAgICAgICAgbWFyZ2luLWJvdHRvbTogMWVtOwogICAgICAgICAgICAgICAgfQoKICAgICAgICAgICAgICAgICNqbWRjb250ZW50IHRyOmxhc3QtY2hpbGQgewogICAgICAgICAgICAgICAgICAgIG1hcmdpbi1ib3R0b206IDA7CiAgICAgICAgICAgICAgICB9CgogICAgICAgICAgICAgICAgI2ptZGNvbnRlbnQgdGFibGUgdGJvZHkgIHRkIHsKICAgICAgICAgICAgICAgICAgICBib3JkZXI6IG5vbmU7CiAgICAgICAgICAgICAgICAgICAgYm9yZGVyLWJvdHRvbTogMXB4IHNvbGlkICNlZWU7CiAgICAgICAgICAgICAgICAgICAgcG9zaXRpb246IHJlbGF0aXZlOwogICAgICAgICAgICAgICAgICAgIHdoaXRlLXNwYWNlOiBub3JtYWw7CiAgICAgICAgICAgICAgICAgICAgdGV4dC1hbGlnbjogbGVmdDsKICAgICAgICAgICAgICAgICAgICBwYWRkaW5nOiA1cHggMTBweCA1cHggY2FsYygzMCUgKyAyMHB4KTsKICAgICAgICAgICAgICAgIH0KCiAgICAgICAgICAgICAgICAjam1kY29udGVudCB0YWJsZSB0Ym9keSB0ZDpiZWZvcmUgewogICAgICAgICAgICAgICAgICAgIGNvbnRlbnQ6IGF0dHIoZGF0YS1oZWFkZXIpOwogICAgICAgICAgICAgICAgICAgIHBvc2l0aW9uOiBhYnNvbHV0ZTsKICAgICAgICAgICAgICAgICAgICB0b3A6IDFweDsKICAgICAgICAgICAgICAgICAgICBsZWZ0OiAxcHg7CiAgICAgICAgICAgICAgICAgICAgd2lkdGg6IDMwJTsKICAgICAgICAgICAgICAgICAgICBwYWRkaW5nOiA1cHggMTBweDsKICAgICAgICAgICAgICAgICAgICB3aGl0ZS1zcGFjZTogbm93cmFwOwogICAgICAgICAgICAgICAgICAgIHRleHQtYWxpZ246IGxlZnQ7CiAgICAgICAgICAgICAgICAgICAgZm9udC13ZWlnaHQ6IGJvbGQ7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0KCjwvc3R5bGU+CjxkaXYgaWQ9ImptZGNvbnRlbnQiIGRhdGEtamlkPSI2MDQ5MDIiIGRhdGEtanR5cGU9InBvbGljeSIgbGFuZz0iZGUiPjxoMSBpZD0ianNlY3Rpb25kYXRlbnNjaHV0emVya2xydW5nIj5Qb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqTwvaDE+CjxwPk9uIGVzdCByYXZpcyBxdWUgdHUgYWllcyB2aXNpdMOpIG5vdHJlIHNpdGUgdGlzc2kuZGUgZXQgcXVlIHR1IHQnaW50w6lyZXNzZXMgw6Agbm90cmUgZW50cmVwcmlzZS48L3A+CjxwPkxhIHByb3RlY3Rpb24gZGUgdGVzIGRvbm7DqWVzIHBlcnNvbm5lbGxlcywgY29tbWUgdGEgZGF0ZSBkZSBuYWlzc2FuY2UsIHRvbiBub20sIHRvbiBudW3DqXJvIGRlIHTDqWzDqXBob25lLCB0b24gYWRyZXNzZSwgZXRjLiwgZXN0IHRyw6hzIGltcG9ydGFudGUgcG91ciBub3VzLjwvcD4KPHA+Q2V0dGUgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kgYSBwb3VyIGJ1dCBkZSB0J2luZm9ybWVyIHN1ciBsZSB0cmFpdGVtZW50IGRlIHRlcyBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCBxdWUgbm91cyBjb2xsZWN0b25zIGxvcnNxdWUgdHUgdmlzaXRlcyBub3RyZSBzaXRlLgpOb3MgcHJhdGlxdWVzIGVuIG1hdGnDqHJlIGRlIHByb3RlY3Rpb24gZGVzIGRvbm7DqWVzIHNvbnQgY29uZm9ybWVzIGF1eCBkaXNwb3NpdGlvbnMgbMOpZ2FsZXMgZHUgUsOoZ2xlbWVudCBnw6luw6lyYWwgc3VyIGxhIHByb3RlY3Rpb24gZGVzIGRvbm7DqWVzIGRlIGwnVUUgKFJHUEQpIGV0IGRlIGxhIGxvaSBmw6lkw6lyYWxlIGFsbGVtYW5kZSBzdXIgbGEgcHJvdGVjdGlvbiBkZXMgZG9ubsOpZXMgKEJEU0cpLgpMYSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqSBjaS1kZXNzb3VzIHZpc2Ugw6AgcmVzcGVjdGVyIGxlcyBvYmxpZ2F0aW9ucyBkJ2luZm9ybWF0aW9uIGTDqWNvdWxhbnQgZHUgUkdQRC4KQ2VsbGVzLWNpIGZpZ3VyZW50IG5vdGFtbWVudCBhdXggYXJ0aWNsZXMgMTMgZXQgMTQgZXQgc3VpdmFudHMgZHUgUkdQRC48L3A+CjxoMiBpZD0ianNlY3Rpb25hbmFtZXJlc3BvbnNpYmxlZW50aXR5YXZlcmFudHdvcnRsaWNoZXIiPjxhIG5hbWU9InJlc3BvbnNpYmxlLWVudGl0eSI+PC9hPiAgUmVzcG9uc2FibGU8L2gyPgo8cD5MZSByZXNwb25zYWJsZSBkdSB0cmFpdGVtZW50IGF1IHNlbnMgZGUgbCdhcnRpY2xlIDQsIHBvaW50IDcsIGR1IFJHUEQgZXN0IGxhIHBlcnNvbm5lIHF1aSwgc2V1bGUgb3UgY29uam9pbnRlbWVudCBhdmVjIGQnYXV0cmVzLCBkw6l0ZXJtaW5lIGxlcyBmaW5hbGl0w6lzIGV0IGxlcyBtb3llbnMgZHUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwuPC9wPgo8cD5FbiBjZSBxdWkgY29uY2VybmUgbm90cmUgc2l0ZSBJbnRlcm5ldCwgbGUgcmVzcG9uc2FibGUgZXN0IDo8L3A+CjxwPk0uSi4gT3N0ZXIgR21iSAoKQ2FsbW9uc3RyYcOfZSA4Cgo1NjgxNCBCcmVtbQoKQWxsZW1hZ25lCgpFLW1haWwgOiA8YSBocmVmPSJtYWlsdG86aW5mb0B0aXNzaS5kZSIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aW5mb0B0aXNzaS5kZTwvYT4KClTDqWwuIDogMDI2NzU5MTE0NDAKCkZheCA6IDAyNjc1OTExNDQxNSAgPC9wPgo8aDIgaWQ9ImpzZWN0aW9uYmVyZWl0c3RlbGx1bmdkZXJ3ZWJzaXRldW5kZXJzdGVsbHVuZ3ZvbmxvZ2ZpbGVzIj5NaXNlIMOgIGRpc3Bvc2l0aW9uIGR1IHNpdGUgd2ViIGV0IGNyw6lhdGlvbiBkZSBmaWNoaWVycyBqb3VybmF1eDwvaDI+CjxwPsOAIGNoYXF1ZSBmb2lzIHF1ZSB0dSBjb25zdWx0ZXMgbm90cmUgc2l0ZSBJbnRlcm5ldCwgbm90cmUgc3lzdMOobWUgZW5yZWdpc3RyZSBhdXRvbWF0aXF1ZW1lbnQgZGVzIGRvbm7DqWVzIGV0IGRlcyBpbmZvcm1hdGlvbnMgY29uY2VybmFudCBsJ2FwcGFyZWlsIHV0aWxpc8OpIChwYXIgZXhlbXBsZSwgdW4gb3JkaW5hdGV1ciwgdW4gdMOpbMOpcGhvbmUgcG9ydGFibGUsIHVuZSB0YWJsZXR0ZSwgZXRjLikuPC9wPgo8aDQgaWQ9ImpzZWN0aW9ud2VsY2hlcGVyc29uZW5iZXpvZ2VuZW5kYXRlbndlcmRlbmVyaG9iZW51bmRpbndlbGNoZW11bWZhbmd3ZXJkZW5kaWVzZXZlcmFyYmVpdGV0Ij5RdWVsbGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIHNvbnQgY29sbGVjdMOpZXMgZXQgZGFucyBxdWVsbGUgbWVzdXJlIHNvbnQtZWxsZXMgdHJhaXTDqWVzID88L2g0Pgo8cD4oMSkgRGVzIGluZm9zIHN1ciBsZSB0eXBlIGRlIG5hdmlnYXRldXIgZXQgbGEgdmVyc2lvbiB1dGlsaXPDqWUgOwoKKDIpIExlIHN5c3TDqG1lIGQnZXhwbG9pdGF0aW9uIGRlIGwnYXBwYXJlaWwgdXRpbGlzw6kgOwoKKDMpIExlIG5vbSBkJ2jDtHRlIGRlIGwnb3JkaW5hdGV1ciBxdWkgYWNjw6hkZSBhdSBzaXRlIDsKCig0KSBMJ2FkcmVzc2UgSVAgZGUgbCdhcHBhcmVpbCB1dGlsaXPDqSBwb3VyIGFjY8OpZGVyIGF1IHNpdGUgOwoKKDUpIExhIGRhdGUgZXQgbCdoZXVyZSBkZSBsJ2FjY8OocyA7CgooNikgTGVzIHBhZ2VzIHdlYiBldCBsZXMgcmVzc291cmNlcyAoaW1hZ2VzLCBmaWNoaWVycywgYXV0cmVzIGNvbnRlbnVzKSBjb25zdWx0w6llcyBzdXIgbm90cmUgc2l0ZSA7CgooNykgTGVzIHNpdGVzIHdlYiDDoCBwYXJ0aXIgZGVzcXVlbHMgbGUgc3lzdMOobWUgZGUgbCd1dGlsaXNhdGV1ciBhIGFjY8OpZMOpIMOgIG5vdHJlIHNpdGUgd2ViIChzdWl2aSBkZXMgcsOpZsOpcmVudHMpIDsKCig4KSBJbmRpY2F0aW9uIHByw6ljaXNhbnQgc2kgbGEgY29uc3VsdGF0aW9uIGEgYWJvdXRpIDsKCig5KSBWb2x1bWUgZGUgZG9ubsOpZXMgdHJhbnNmw6lyw6llcyAgPC9wPgo8cD5DZXMgZG9ubsOpZXMgc29udCBlbnJlZ2lzdHLDqWVzIGRhbnMgbGVzIGZpY2hpZXJzIGpvdXJuYXV4IGRlIG5vdHJlIHN5c3TDqG1lLgpDZXMgZG9ubsOpZXMgbmUgc29udCBwYXMgZW5yZWdpc3Ryw6llcyBhdmVjIGxlcyBkb25uw6llcyBwZXJzb25uZWxsZXMgZCd1biB1dGlsaXNhdGV1ciBlbiBwYXJ0aWN1bGllciwgY2UgcXVpIGVtcMOqY2hlIHRvdXRlIGlkZW50aWZpY2F0aW9uIGRlcyB2aXNpdGV1cnMgaW5kaXZpZHVlbHMgZHUgc2l0ZS48L3A+CjxoNCBpZD0ianNlY3Rpb25yZWNodHNncnVuZGxhZ2VmcmRpZXZlcmFyYmVpdHVuZ3BlcnNvbmVuYmV6b2dlbmVyZGF0ZW4iPkJhc2UganVyaWRpcXVlIGR1IHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsPC9oND4KPHA+QXJ0LiA2LCBhbC4gMSwgbGV0LiBmIGR1IFJHUEQgKGludMOpcsOqdCBsw6lnaXRpbWUpLiAgCk5vdHJlIGludMOpcsOqdCBsw6lnaXRpbWUgY29uc2lzdGUgw6AgZ2FyYW50aXIgbGEgcsOpYWxpc2F0aW9uIGRlIGwnb2JqZWN0aWYgZMOpY3JpdCBjaS1kZXNzb3VzLjwvcD4KPGg0IGlkPSJqc2VjdGlvbnp3ZWNrZGVyZGF0ZW52ZXJhcmJlaXR1bmciPkZpbmFsaXTDqSBkdSB0cmFpdGVtZW50IGRlcyBkb25uw6llczwvaDQ+CjxwPkxlIHN0b2NrYWdlIHRlbXBvcmFpcmUgKGF1dG9tYXRpc8OpKSBkZXMgZG9ubsOpZXMgZXN0IG7DqWNlc3NhaXJlIGF1IGJvbiBkw6lyb3VsZW1lbnQgZCd1bmUgdmlzaXRlIHN1ciBsZSBzaXRlIHdlYiwgYWZpbiBkZSBwZXJtZXR0cmUgbCdhZmZpY2hhZ2UgZHUgc2l0ZS4KTGEgY29uc2VydmF0aW9uIGV0IGxlIHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIG9udCDDqWdhbGVtZW50IHBvdXIgYnV0IGRlIGdhcmFudGlyIGxhIGNvbXBhdGliaWxpdMOpIGRlIG5vdHJlIHNpdGUgd2ViIHBvdXIgbGUgcGx1cyBncmFuZCBub21icmUgcG9zc2libGUgZGUgdmlzaXRldXJzLCBhaW5zaSBxdWUgZGUgbHV0dGVyIGNvbnRyZSBsZXMgYWJ1cyBldCBkZSByZW3DqWRpZXIgYXV4IGR5c2ZvbmN0aW9ubmVtZW50cy4KUG91ciDDp2EsIG9uIGRvaXQgZW5yZWdpc3RyZXIgbGVzIGRvbm7DqWVzIHRlY2huaXF1ZXMgZGUgbCdvcmRpbmF0ZXVyIHF1aSBzZSBjb25uZWN0ZSwgcG91ciBwb3V2b2lyIHLDqWFnaXIgbGUgcGx1cyB2aXRlIHBvc3NpYmxlIGF1eCBlcnJldXJzIGQnYWZmaWNoYWdlLCBhdXggYXR0YXF1ZXMgY29udHJlIG5vcyBzeXN0w6htZXMgaW5mb3JtYXRpcXVlcyBldC9vdSBhdXggZHlzZm9uY3Rpb25uZW1lbnRzIGRlIG5vdHJlIHNpdGUgd2ViLgpFbiBwbHVzLCBjZXMgZG9ubsOpZXMgbm91cyBzZXJ2ZW50IMOgIG9wdGltaXNlciBsZSBzaXRlIHdlYiBldCDDoCBnYXJhbnRpciBkZSBtYW5pw6hyZSBnw6luw6lyYWxlIGxhIHPDqWN1cml0w6kgZGUgbm9zIHN5c3TDqG1lcyBpbmZvcm1hdGlxdWVzLjwvcD4KPGg0IGlkPSJqc2VjdGlvbmRhdWVyZGVyc3BlaWNoZXJ1bmciPkR1csOpZSBkZSBjb25zZXJ2YXRpb248L2g0Pgo8cD5MZXMgZG9ubsOpZXMgdGVjaG5pcXVlcyBtZW50aW9ubsOpZXMgY2ktZGVzc3VzIHNvbnQgc3VwcHJpbcOpZXMgZMOocyBxdSdlbGxlcyBuZSBzb250IHBsdXMgbsOpY2Vzc2FpcmVzIHBvdXIgZ2FyYW50aXIgbGEgY29tcGF0aWJpbGl0w6kgZHUgc2l0ZSB3ZWIgcG91ciB0b3VzIGxlcyB2aXNpdGV1cnMsIG1haXMgYXUgcGx1cyB0YXJkIDMgbW9pcyBhcHLDqHMgbGEgY29uc3VsdGF0aW9uIGRlIG5vdHJlIHNpdGUgd2ViLjwvcD4KPGg0IGlkPSJqc2VjdGlvbndpZGVyc3BydWNoc3VuZGxzY2h1bmdzbWdsaWNoa2VpdCI+UG9zc2liaWxpdMOpIGQnb3Bwb3NpdGlvbiBldCBkZSByYWRpYXRpb248L2g0Pgo8cD5UdSBwZXV4IMOgIHRvdXQgbW9tZW50IHQnb3Bwb3NlciBhdSB0cmFpdGVtZW50IGRlIHRlcyBkb25uw6llcyBjb25mb3Jtw6ltZW50IMOgIGwnYXJ0aWNsZSAyMSBkdSBSR1BEIGV0IGRlbWFuZGVyIGxldXIgZWZmYWNlbWVudCBjb25mb3Jtw6ltZW50IMOgIGwnYXJ0aWNsZSAxNyBkdSBSR1BELgpUdSB0cm91dmVyYXMgZW4gYmFzIGRlIGNldHRlIHBvbGl0aXF1ZSBkZSBjb25maWRlbnRpYWxpdMOpIGxhIGxpc3RlIGRlIHRlcyBkcm9pdHMgZXQgbGEgbWFyY2hlIMOgIHN1aXZyZSBwb3VyIGxlcyBmYWlyZSB2YWxvaXIuICA8L3A+CjxoMiBpZD0ianNlY3Rpb25iZXNvbmRlcmVmdW5rdGlvbmVuZGVyaW50ZXJuZXRzZWl0ZSI+Rm9uY3Rpb25uYWxpdMOpcyBzcMOpY2lmaXF1ZXMgZHUgc2l0ZSB3ZWI8L2gyPgo8cD5Ob3RyZSBzaXRlIHRlIHByb3Bvc2UgZGlmZsOpcmVudGVzIGZvbmN0aW9ubmFsaXTDqXMgcXVpLCBsb3JzcXVlIHR1IGxlcyB1dGlsaXNlcywgbm91cyBhbcOobmVudCDDoCBjb2xsZWN0ZXIsIHRyYWl0ZXIgZXQgc3RvY2tlciBkZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwuCk9uIHQnZXhwbGlxdWUgY2ktZGVzc291cyBjZSBxdSdvbiBmYWl0IGRlIGNlcyBkb25uw6llcyA6PC9wPgo8aDMgaWQ9ImpzZWN0aW9uYmVzdGVsbGZvcm11bGFyIj5Gb3JtdWxhaXJlIGRlIGNvbW1hbmRlPC9oMz4KPHVsPgo8bGk+PGg0IGlkPSJqc2VjdGlvbndlbGNoZXBlcnNvbmVuYmV6b2dlbmVuZGF0ZW53ZXJkZW5lcmhvYmVudW5kaW53ZWxjaGVtdW1mYW5nd2VyZGVuZGllc2V2ZXJhcmJlaXRldC0xIj5RdWVsbGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIHNvbnQgY29sbGVjdMOpZXMgZXQgZGFucyBxdWVsbGUgbWVzdXJlIHNvbnQtZWxsZXMgdHJhaXTDqWVzID88L2g0Pgo8cD5MZXMgZG9ubsOpZXMgcXVlIHR1IGFzIHNhaXNpZXMgZGFucyBsZXMgY2hhbXBzIGR1IGZvcm11bGFpcmUsIGNvbW1lIHRvbiBhZHJlc3NlLCB0b24gbm9tLCB0b24gcHLDqW5vbSwgZXRjLiwgc29udCB0cmFpdMOpZXMgcGFyIG5vcyBzb2lucyBhZmluIGRlIHLDqXBvbmRyZSDDoCBsJ29iamVjdGlmIG1lbnRpb25uw6kgY2ktZGVzc291cy48L3A+PC9saT4KPGxpPjxoNCBpZD0ianNlY3Rpb25yZWNodHNncnVuZGxhZ2VmcmRpZXZlcmFyYmVpdHVuZ3BlcnNvbmVuYmV6b2dlbmVyZGF0ZW4tMSI+QmFzZSBqdXJpZGlxdWUgZHUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWw8L2g0Pgo8cD5BcnQuIDYsIGFsLiAxLCBsZXQuIGIgZHUgUkdQRCAobWlzZSBlbiDFk3V2cmUgZGUgbWVzdXJlcyAocHLDqSljb250cmFjdHVlbGxlcyk8L3A+PC9saT4KPGxpPjxoNCBpZD0ianNlY3Rpb256d2Vja2RlcmRhdGVudmVyYXJiZWl0dW5nLTEiPkZpbmFsaXTDqSBkdSB0cmFpdGVtZW50IGRlcyBkb25uw6llczwvaDQ+CjxwPkxlIHRyYWl0ZW1lbnQgZGUgdGVzIGRvbm7DqWVzIGEgcG91ciBidXQgZGUgdHJhaXRlciB0YSBjb21tYW5kZSwgYWZpbiBxdWUgbm91cyBwdWlzc2lvbnMgw6l0YWJsaXIgZCfDqXZlbnR1ZWxsZXMgcmVsYXRpb25zIGNvbnRyYWN0dWVsbGVzIGF2ZWMgdG9pIG91IHByZW5kcmUgZGVzIG1lc3VyZXMgcHLDqWNvbnRyYWN0dWVsbGVzLjwvcD48L2xpPgo8bGk+PGg0IGlkPSJqc2VjdGlvbmRhdWVyZGVyc3BlaWNoZXJ1bmctMSI+RHVyw6llIGRlIGNvbnNlcnZhdGlvbjwvaDQ+CjxwPkxlcyBkb25uw6llcyBzb250IHN1cHByaW3DqWVzIGTDqHMgcXUnZWxsZXMgbmUgc29udCBwbHVzIG7DqWNlc3NhaXJlcyBhdSB0cmFpdGVtZW50IGRlIGxhIGNvbW1hbmRlIGV0IHF1J2lsIG4neSBhIHBsdXMgZCdvYmxpZ2F0aW9ucyBsw6lnYWxlcyBkZSBjb25zZXJ2YXRpb24uCkMnZXN0IGfDqW7DqXJhbGVtZW50IGxlIGNhcyBhdSBib3V0IGRlIDEwIGFucyAoY2YuIMKnIDE0NywgYWwuIDMsIGVuIGxpYWlzb24gYXZlYyBsJ2FsLiAxLCBuwrAgMSwgNCBldCA0YSBkdSBDb2RlIGZpc2NhbCBhbGxlbWFuZCAoQU8pLCDCpyAxNGIsIGFsLiAxIGRlIGxhIGxvaSBhbGxlbWFuZGUgc3VyIGxhIFRWQSAoVVN0RykpLjwvcD48L2xpPgo8bGk+PGg0IGlkPSJqc2VjdGlvbndpZGVyc3BydWNoc3VuZGxzY2h1bmdzbWdsaWNoa2VpdC0xIj5Qb3NzaWJpbGl0w6kgZCdvcHBvc2l0aW9uIGV0IGRlIHJhZGlhdGlvbjwvaDQ+CjxwPlR1IHRyb3V2ZXJhcyBlbiBiYXMgZGUgY2V0dGUgZMOpY2xhcmF0aW9uIGRlIGNvbmZpZGVudGlhbGl0w6kgcXVlbHMgc29udCB0ZXMgZHJvaXRzIGV0IGNvbW1lbnQgbGVzIGZhaXJlIHZhbG9pci48L3A+PC9saT4KPGxpPjxoNCBpZD0ianNlY3Rpb25lcmZvcmRlcmxpY2hrZWl0ZGVyYW5nYWJlcGVyc29uZW5iZXpvZ2VuZXJkYXRlbiI+TsOpY2Vzc2l0w6kgZGUgZm91cm5pciBkZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWw8L2g0Pgo8cD5MZXMgaW5mb3JtYXRpb25zIGRlbWFuZMOpZXMgZGFucyBsZSBmb3JtdWxhaXJlIGRlIGNvbW1hbmRlIG5lIHNvbnQgcGFzIG9ibGlnYXRvaXJlcyBkJ3VuIHBvaW50IGRlIHZ1ZSBjb250cmFjdHVlbCBvdSBsw6lnYWwsIG1haXMgZWxsZXMgc29udCBuw6ljZXNzYWlyZXMgcG91ciBjb25jbHVyZSB1biBjb250cmF0LgpTaSB0dSBuZSByZW1wbGlzIHBhcyBvdSBwYXMgZW50acOocmVtZW50IGxlcyBjaGFtcHMgb2JsaWdhdG9pcmVzLCBsYSBjb21tYW5kZSBxdWUgdHUgc291aGFpdGVzIHBhc3NlciBuZSBwb3VycmEgcGFzIMOqdHJlIGZpbmFsaXPDqWUuPC9wPjwvbGk+CjwvdWw+CjxoMyBpZD0ianNlY3Rpb25iZXdlcmJ1bmdzZm9ybXVsYXIiPkZvcm11bGFpcmUgZGUgY2FuZGlkYXR1cmU8L2gzPgo8dWw+CjxsaT48aDQgaWQ9ImpzZWN0aW9ud2VsY2hlcGVyc29uZW5iZXpvZ2VuZW5kYXRlbndlcmRlbmVyaG9iZW51bmRpbndlbGNoZW11bWZhbmd3ZXJkZW5kaWVzZXZlcmFyYmVpdGV0LTIiPlF1ZWxsZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgc29udCBjb2xsZWN0w6llcyBldCBkYW5zIHF1ZWxsZSBtZXN1cmUgc29udC1lbGxlcyB0cmFpdMOpZXMgPzwvaDQ+CjxwPkxlcyBkb25uw6llcyBxdWUgdHUgYXMgc2Fpc2llcyBkYW5zIGxlcyBjaGFtcHMgZHUgZm9ybXVsYWlyZSBkZSBjYW5kaWRhdHVyZSBldCwgbGUgY2FzIMOpY2jDqWFudCwgY2VsbGVzIHF1ZSB0dSBhcyB0w6lsw6ljaGFyZ8OpZXMsIHNlcm9udCB0cmFpdMOpZXMgZGFucyBsZXVyIGludMOpZ3JhbGl0w6kgYWZpbiBkZSByw6lwb25kcmUgw6AgbCdvYmplY3RpZiBtZW50aW9ubsOpIGNpLWRlc3NvdXMuPC9wPjwvbGk+CjxsaT48aDQgaWQ9ImpzZWN0aW9ucmVjaHRzZ3J1bmRsYWdlZnJkaWV2ZXJhcmJlaXR1bmdwZXJzb25lbmJlem9nZW5lcmRhdGVuLTIiPkJhc2UganVyaWRpcXVlIGR1IHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsPC9oND4KPHA+TGEgYmFzZSBqdXJpZGlxdWUgcG91ciBsYSBjb2xsZWN0ZSBldCBsZSB0cmFpdGVtZW50IGRlcyBkb25uw6llcyBkZXMgY2FuZGlkYXRzIGVzdCBsJ2FydGljbGUgNiwgcGFyYWdyYXBoZSAxLCBwb2ludCBiKSAocHLDqXBhcmF0aW9uIGQndW4gY29udHJhdCksIGwnYXJ0aWNsZSA4OCwgcGFyYWdyYXBoZSAxLCBkdSBSR1BELCBlbiBsaWFpc29uIGF2ZWMgbCdhcnRpY2xlIDI2IGRlIGxhIEJEU0cuCkRhbnMgbGEgbWVzdXJlIG\/DuSBkZXMgY2F0w6lnb3JpZXMgcGFydGljdWxpw6hyZXMgZGUgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgc29udCBjb2xsZWN0w6llcywgcXVpIHNvbnQgbsOpY2Vzc2FpcmVzIGF1IHJlc3BlY3QgZGVzIG9ibGlnYXRpb25zIGzDqWdhbGVzIGTDqWNvdWxhbnQgZHUgZHJvaXQgZHUgdHJhdmFpbCwgZHUgZHJvaXQgZGUgbGEgc8OpY3VyaXTDqSBzb2NpYWxlIGV0IGRlIGxhIHByb3RlY3Rpb24gc29jaWFsZSBjb25mb3Jtw6ltZW50IMOgIGwnYXJ0aWNsZSA5LCBwYXJhZ3JhcGhlIDIgYiBkdSBSR1BELCBlbiBsaWFpc29uIGF2ZWMgbOKAmWFydGljbGUgMjYsIHBhcmFncmFwaGUgMywgZGUgbGEgQkRTRywgbGUgdHJhaXRlbWVudCBz4oCZZWZmZWN0dWUgc3VyIGNldHRlIGJhc2UganVyaWRpcXVlLgpTaSwgZW4gb3V0cmUsIGRlcyBjYXTDqWdvcmllcyBwYXJ0aWN1bGnDqHJlcyBkZSBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCBkb2l2ZW50IMOqdHJlIHRyYWl0w6llcywgb24gZGVtYW5kZXJhIHRvbiBjb25zZW50ZW1lbnQgY29uZm9ybcOpbWVudCDDoCBs4oCZYXJ0aWNsZSA5LCBwYXJhZ3JhcGhlIDIsIHBvaW50IGEpIGR1IFJHUEQuICAgICAgIDwvcD48L2xpPgo8bGk+PGg0IGlkPSJqc2VjdGlvbnp3ZWNrZGVyZGF0ZW52ZXJhcmJlaXR1bmctMiI+RmluYWxpdMOpIGR1IHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzPC9oND4KPHA+TGUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgYSBwb3VyIGJ1dCBkJ2V4YW1pbmVyIGV0IGRlIHRyYWl0ZXIgbGVzIGRvY3VtZW50cyBkZSBjYW5kaWRhdHVyZSBxdWUgdHUgYXMgdMOpbMOpY2hhcmfDqXMgdmlhIGxlIGZvcm11bGFpcmUuPC9wPjwvbGk+CjxsaT48aDQgaWQ9ImpzZWN0aW9uZGF1ZXJkZXJzcGVpY2hlcnVuZy0yIj5EdXLDqWUgZGUgY29uc2VydmF0aW9uPC9oND4KPHA+TGVzIGRvbm7DqWVzIHNvbnQgc3VwcHJpbcOpZXMgZMOocyBxdWUgdGEgY2FuZGlkYXR1cmUgYSDDqXTDqSB0cmFpdMOpZSBldCBxdSdpbCBuJ3kgYSBwbHVzIGQnaW50w6lyw6p0IGzDqWdpdGltZSDDoCBjb25zZXJ2ZXIgbGVzIGRvbm7DqWVzIGRlIGNhbmRpZGF0dXJlLgpTaSB0dSBuJ2VzIHBhcyBlbWJhdWNow6ksIHRvbiBkb3NzaWVyIGRlIGNhbmRpZGF0dXJlIHNlcmEgZG9uYyBzdXBwcmltw6kgYXUgcGx1cyB0YXJkIGF1IGJvdXQgZGUgNiBtb2lzLjwvcD48L2xpPgo8bGk+PGg0IGlkPSJqc2VjdGlvbndpZGVyc3BydWNoc3VuZGxzY2h1bmdzbWdsaWNoa2VpdC0yIj5Qb3NzaWJpbGl0w6kgZCdvcHBvc2l0aW9uIGV0IGRlIHJhZGlhdGlvbjwvaDQ+CjxwPlR1IHRyb3V2ZXJhcyBlbiBiYXMgZGUgY2V0dGUgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kgcXVlbHMgc29udCB0ZXMgZHJvaXRzIGV0IGNvbW1lbnQgbGVzIGZhaXJlIHZhbG9pci48L3A+PC9saT4KPGxpPjxoNCBpZD0ianNlY3Rpb25lcmZvcmRlcmxpY2hrZWl0ZGVyYW5nYWJlcGVyc29uZW5iZXpvZ2VuZXJkYXRlbi0xIj5Ow6ljZXNzaXTDqSBkZSBmb3VybmlyIGRlcyBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbDwvaDQ+CjxwPkxlcyBpbmZvcm1hdGlvbnMgZGVtYW5kw6llcyBkYW5zIGxlIGZvcm11bGFpcmUgZGUgY2FuZGlkYXR1cmUgbmUgc29udCBwYXMgb2JsaWdhdG9pcmVzIGQndW4gcG9pbnQgZGUgdnVlIGNvbnRyYWN0dWVsIG91IGzDqWdhbCwgbWFpcyBlbGxlcyBzb250IG7DqWNlc3NhaXJlcyBwb3VyIGVudm95ZXIgZXQgdHJhaXRlciB0YSBjYW5kaWRhdHVyZS4gU2kgdHUgbmUgcmVtcGxpcyBwYXMgb3UgcGFzIGVudGnDqHJlbWVudCBsZXMgY2hhbXBzIG9ibGlnYXRvaXJlcywgdGEgY2FuZGlkYXR1cmUgbmUgcG91cnJhIHBhcyDDqnRyZSBlbnZvecOpZSBuaSB0cmFpdMOpZS4gPC9wPjwvbGk+CjwvdWw+CjxoMyBpZD0ianNlY3Rpb25rb250YWt0Zm9ybXVsYXJlIj5Gb3JtdWxhaXJlKHMpIGRlIGNvbnRhY3Q8L2gzPgo8dWw+CjxsaT48aDQgaWQ9ImpzZWN0aW9ud2VsY2hlcGVyc29uZW5iZXpvZ2VuZW5kYXRlbndlcmRlbmVyaG9iZW51bmRpbndlbGNoZW11bWZhbmd3ZXJkZW5kaWVzZXZlcmFyYmVpdGV0LTMiPlF1ZWxsZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgc29udCBjb2xsZWN0w6llcyBldCBkYW5zIHF1ZWxsZSBtZXN1cmUgc29udC1lbGxlcyB0cmFpdMOpZXMgPzwvaDQ+CjxwPk9uIHRyYWl0ZXJhIGxlcyBkb25uw6llcyBxdWUgdHUgYXMgc2Fpc2llcyBkYW5zIG5vcyBmb3JtdWxhaXJlcyBkZSBjb250YWN0LCBjJ2VzdC3DoC1kaXJlIGNlbGxlcyBxdWUgdHUgYXMgcmVuc2VpZ27DqWVzIGRhbnMgbGUgY2hhbXAgZHUgZm9ybXVsYWlyZSBkZSBjb250YWN0LCBhZmluIGRlIHLDqXBvbmRyZSDDoCBsJ29iamVjdGlmIG1lbnRpb25uw6kgY2ktZGVzc291cy48L3A+PC9saT4KPGxpPjxoNCBpZD0ianNlY3Rpb25yZWNodHNncnVuZGxhZ2VmcmRpZXZlcmFyYmVpdHVuZ3BlcnNvbmVuYmV6b2dlbmVyZGF0ZW4tMyI+QmFzZSBqdXJpZGlxdWUgZHUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWw8L2g0Pgo8cD5BcnQuIDYsIGFsLiAxLCBsZXQuIGEgZHUgUkdQRCAoY29uc2VudGVtZW50IGV4cHJpbcOpIHBhciB1biBhY3RlIG91IHVuIGNvbXBvcnRlbWVudCBjbGFpciBldCBhZmZpcm1hdGlmKTwvcD48L2xpPgo8bGk+PGg0IGlkPSJqc2VjdGlvbnp3ZWNrZGVyZGF0ZW52ZXJhcmJlaXR1bmctMyI+RmluYWxpdMOpIGR1IHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzPC9oND4KPHA+T24gdXRpbGlzZXJhIGxlcyBkb25uw6llcyBjb2xsZWN0w6llcyB2aWEgbm90cmUgZm9ybXVsYWlyZSBkZSBjb250YWN0LCBvdSBub3MgZm9ybXVsYWlyZXMgZGUgY29udGFjdCwgdW5pcXVlbWVudCBwb3VyIHRyYWl0ZXIgbGEgZGVtYW5kZSBkZSBjb250YWN0IHNww6ljaWZpcXVlIHF1aSBub3VzIGVzdCBlbnZvecOpZSB2aWEgY2UgZm9ybXVsYWlyZS48L3A+PC9saT4KPGxpPjxoNCBpZD0ianNlY3Rpb25kYXVlcmRlcnNwZWljaGVydW5nLTMiPkR1csOpZSBkZSBjb25zZXJ2YXRpb248L2g0Pgo8cD5VbmUgZm9pcyB0YSBkZW1hbmRlIHRyYWl0w6llLCBsZXMgZG9ubsOpZXMgY29sbGVjdMOpZXMgc2Vyb250IGltbcOpZGlhdGVtZW50IHN1cHByaW3DqWVzLCBzYXVmIHMnaWwgZXhpc3RlIGRlcyBkw6lsYWlzIGRlIGNvbnNlcnZhdGlvbiBsw6lnYXV4LjwvcD48L2xpPgo8bGk+PGg0IGlkPSJqc2VjdGlvbndpZGVycnVmc3VuZGxzY2h1bmdzbWdsaWNoa2VpdCI+UG9zc2liaWxpdMOpcyBkZSByw6l0cmFjdGF0aW9uIGV0IGRlIHN1cHByZXNzaW9uPC9oND4KPHA+TGVzIHBvc3NpYmlsaXTDqXMgZGUgcsOpdHJhY3RhdGlvbiBldCBkZSBzdXBwcmVzc2lvbiBzb250IHLDqWdpZXMgcGFyIGxlcyBkaXNwb3NpdGlvbnMgZ8OpbsOpcmFsZXMgcmVsYXRpdmVzIGF1IGRyb2l0IGRlIHLDqXRyYWN0YXRpb24gZXQgYXUgZHJvaXQgw6AgbCdlZmZhY2VtZW50IGVuIG1hdGnDqHJlIGRlIHByb3RlY3Rpb24gZGVzIGRvbm7DqWVzLCBkw6ljcml0ZXMgY2ktYXByw6hzIGRhbnMgbGEgcHLDqXNlbnRlIHBvbGl0aXF1ZSBkZSBjb25maWRlbnRpYWxpdMOpLjwvcD48L2xpPgo8bGk+PGg0IGlkPSJqc2VjdGlvbmVyZm9yZGVybGljaGtlaXRkZXJhbmdhYmVwZXJzb25lbmJlem9nZW5lcmRhdGVuLTIiPk7DqWNlc3NpdMOpIGRlIGZvdXJuaXIgZGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsPC9oND4KPHA+TCd1dGlsaXNhdGlvbiBkZXMgZm9ybXVsYWlyZXMgZGUgY29udGFjdCBlc3QgZmFjdWx0YXRpdmUgZXQgbidlc3QgaW1wb3PDqWUgbmkgcGFyIGNvbnRyYXQgbmkgcGFyIGxhIGxvaS4KVHUgbidlcyBwYXMgb2JsaWfDqSBkZSBub3VzIGNvbnRhY3RlciB2aWEgbGUgZm9ybXVsYWlyZSBkZSBjb250YWN0LCB0dSBwZXV4IGF1c3NpIHV0aWxpc2VyIGxlcyBhdXRyZXMgbW95ZW5zIGRlIGNvbnRhY3QgaW5kaXF1w6lzIHN1ciBub3RyZSBzaXRlLgpTaSB0dSBzb3VoYWl0ZXMgdXRpbGlzZXIgbm90cmUgZm9ybXVsYWlyZSBkZSBjb250YWN0LCB0dSBkb2lzIHJlbXBsaXIgbGVzIGNoYW1wcyBtYXJxdcOpcyBjb21tZSBvYmxpZ2F0b2lyZXMuClNpIHR1IG5lIHJlbXBsaXMgcGFzIGxlcyBjaGFtcHMgb2JsaWdhdG9pcmVzIGR1IGZvcm11bGFpcmUgZGUgY29udGFjdCwgc29pdCB0dSBuZSBwb3VycmFzIHBhcyBlbnZveWVyIHRhIGRlbWFuZGUsIHNvaXQgbm91cyBuZSBwb3Vycm9ucyBtYWxoZXVyZXVzZW1lbnQgcGFzIGxhIHRyYWl0ZXIuPC9wPjwvbGk+CjwvdWw+CjxoMyBpZD0ianNlY3Rpb25sb2dpbmJlcmVpY2giPkVzcGFjZSBkZSBjb25uZXhpb248L2gzPgo8dWw+CjxsaT48aDQgaWQ9ImpzZWN0aW9ud2VsY2hlcGVyc29uZW5iZXpvZ2VuZW5kYXRlbndlcmRlbmVyaG9iZW51bmRpbndlbGNoZW11bWZhbmd3ZXJkZW5kaWVzZXZlcmFyYmVpdGV0LTQiPlF1ZWxsZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgc29udCBjb2xsZWN0w6llcyBldCBkYW5zIHF1ZWxsZSBtZXN1cmUgc29udC1lbGxlcyB0cmFpdMOpZXMgPzwvaDQ+CjxwPk9uIHRyYWl0ZXJhIGxlcyBkb25uw6llcyBkJ2luc2NyaXB0aW9uIGV0IGRlIGNvbm5leGlvbiBxdWUgdHUgbm91cyBhcyBmb3VybmllcyBhZmluIGRlIHLDqXBvbmRyZSDDoCBsJ29iamVjdGlmIG1lbnRpb25uw6kgY2ktZGVzc291cy48L3A+PC9saT4KPGxpPjxoNCBpZD0ianNlY3Rpb25yZWNodHNncnVuZGxhZ2VmcmRpZXZlcmFyYmVpdHVuZ3BlcnNvbmVuYmV6b2dlbmVyZGF0ZW4tNCI+QmFzZSBqdXJpZGlxdWUgZHUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWw8L2g0Pgo8cD5BcnQuIDYsIGFsLiAxLCBsZXQuIGIgZHUgUkdQRCAobWlzZSBlbiDFk3V2cmUgZGUgbWVzdXJlcyAocHLDqSljb250cmFjdHVlbGxlcyk8L3A+PC9saT4KPGxpPjxoNCBpZD0ianNlY3Rpb256d2Vja2RlcmRhdGVudmVyYXJiZWl0dW5nLTQiPkZpbmFsaXTDqSBkdSB0cmFpdGVtZW50IGRlcyBkb25uw6llczwvaDQ+CjxwPlN1ciBub3RyZSBzaXRlIEludGVybmV0LCB0dSBhcyBsYSBwb3NzaWJpbGl0w6kgZCdhY2PDqWRlciDDoCB1biBlc3BhY2UgZGUgY29ubmV4aW9uIGTDqWRpw6kuClBvdXIgcXUnb24gcHVpc3NlIHbDqXJpZmllciBxdWUgdHUgZXMgYmllbiBhdXRvcmlzw6kgw6AgYWNjw6lkZXIgw6AgY2V0IGVzcGFjZSBwcm90w6lnw6kgb3Ugw6AgY2VzIGRvY3VtZW50cyBwcm90w6lnw6lzLCB0dSBkb2lzIHNhaXNpciB0ZXMgaWRlbnRpZmlhbnRzIChhZHJlc3NlIGUtbWFpbCBvdSBub20gZCd1dGlsaXNhdGV1ciBldCBtb3QgZGUgcGFzc2UpIGRhbnMgbGUgZm9ybXVsYWlyZSBwcsOpdnUgw6AgY2V0IGVmZmV0LjwvcD48L2xpPgo8bGk+PGg0IGlkPSJqc2VjdGlvbmRhdWVyZGVyc3BlaWNoZXJ1bmctNCI+RHVyw6llIGRlIGNvbnNlcnZhdGlvbjwvaDQ+CjxwPkxlcyBkb25uw6llcyBjb2xsZWN0w6llcyBzb250IGNvbnNlcnbDqWVzIHRhbnQgcXVlIHR1IGFzIHVuIGNvbXB0ZSBjaGV6IG5vdXMuPC9wPjwvbGk+CjxsaT48aDQgaWQ9ImpzZWN0aW9ud2lkZXJzcHJ1Y2hzdW5kbHNjaHVuZ3NtZ2xpY2hrZWl0LTMiPlBvc3NpYmlsaXTDqSBkJ29wcG9zaXRpb24gZXQgZGUgcmFkaWF0aW9uPC9oND4KPHA+VHUgdHJvdXZlcmFzIGVuIGJhcyBkZSBjZXR0ZSBkw6ljbGFyYXRpb24gZGUgY29uZmlkZW50aWFsaXTDqSBxdWVscyBzb250IHRlcyBkcm9pdHMgZXQgY29tbWVudCBsZXMgZmFpcmUgdmFsb2lyLjwvcD48L2xpPgo8bGk+PGg0IGlkPSJqc2VjdGlvbmVyZm9yZGVybGljaGtlaXRkZXJhbmdhYmVwZXJzb25lbmJlem9nZW5lcmRhdGVuLTMiPk7DqWNlc3NpdMOpIGRlIGZvdXJuaXIgZGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsPC9oND4KPHA+TCdhY2PDqHMgw6AgbCdlc3BhY2UgZGUgY29ubmV4aW9uIGRlIG5vdHJlIHNpdGUgZXN0IG9ibGlnYXRvaXJlLCBjb25mb3Jtw6ltZW50IGF1IGNvbnRyYXQsIHBvdXIgcG91dm9pciBhY2PDqWRlciDDoCBsYSB6b25lIHLDqXNlcnbDqWUuCkwnYWNjw6hzIGF1IGNvbnRlbnUgcHJvdMOpZ8OpIHBhciBsJ2VzcGFjZSBkZSBjb25uZXhpb24gbidlc3QgcGFzIHBvc3NpYmxlIHNhbnMgbGEgc2Fpc2llIGRlIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsLgpTaSB0dSBzb3VoYWl0ZXMgdXRpbGlzZXIgbm90cmUgZXNwYWNlIGRlIGNvbm5leGlvbiwgdHUgZG9pcyByZW1wbGlyIGxlcyBjaGFtcHMgbWFycXXDqXMgY29tbWUgb2JsaWdhdG9pcmVzIChub20gZCd1dGlsaXNhdGV1ciBldCBtb3QgZGUgcGFzc2UpLgpQb3VyIHNhaXNpciBjZXMgZG9ubsOpZXMsIHR1IGRvaXMgZGlzcG9zZXIgZOKAmXVuIGNvbXB0ZSB1dGlsaXNhdGV1ci4KVHUgbmUgcG91cnJhcyBwYXMgdGUgY29ubmVjdGVyIHNpIGxlcyBkb25uw6llcyBxdWUgdHUgYXMgc2Fpc2llcyBzb250IGVycm9uw6llcy4KU2kgdHUgc2Fpc2lzIGRlcyBkb25uw6llcyBlcnJvbsOpZXMgb3Ugc2kgdHUgbmUgbGVzIHNhaXNpcyBwYXMgZHUgdG91dCwgdHUgbmUgcG91cnJhcyBwYXMgYWNjw6lkZXIgw6AgbGEgem9uZSBwcm90w6lnw6llLgpMZSByZXN0ZSBkdSBzaXRlIHJlc3RlIHRvdXRlZm9pcyBhY2Nlc3NpYmxlIHNhbnMgY29ubmV4aW9uLjwvcD48L2xpPgo8L3VsPgo8aDIgaWQ9ImpzZWN0aW9uYXV0b21hdGlzaWVydGVib25pdHRzcHJmdW5nc2NvcmluZyI+w4l2YWx1YXRpb24gYXV0b21hdGlzw6llIGRlIGxhIHNvbHZhYmlsaXTDqSAvIHNjb3Jpbmc8L2gyPgo8cD5TaSB0dSBzb3VoYWl0ZXMgY29uY2x1cmUgdW4gY29udHJhdCBhdmVjIG5vdXMsIG9uIHNlIHLDqXNlcnZlIGxlIGRyb2l0IGRlIHByb2PDqWRlciDDoCB1biB0cmFpdGVtZW50IGV4Y2x1c2l2ZW1lbnQgYXV0b21hdGlzw6kgZGUgdGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIGFmaW4gZGUgdsOpcmlmaWVyIHRhIHNvbHZhYmlsaXTDqS4KQ29uZm9ybcOpbWVudCDDoCBs4oCZYXJ0aWNsZSAyMiwgcGFyYWdyYXBoZSAyLCBwb2ludCBhKSBkdSBSR1BELCBvbiBlc3Qgw6lnYWxlbWVudCBhdXRvcmlzw6kgw6AgcHJlbmRyZSB1bmUgdGVsbGUgZMOpY2lzaW9uIGF1dG9tYXRpc8OpZS4KTGEgY29uY2x1c2lvbiBvdSBub24gZHUgY29udHJhdCBkw6lwZW5kIGljaSBkdSByw6lzdWx0YXQgZGUgbGEgdsOpcmlmaWNhdGlvbiBhdXRvbWF0aXPDqWUgZGUgbGEgc29sdmFiaWxpdMOpLgpMb3JzIGTigJl1bmUgdsOpcmlmaWNhdGlvbiBkZSBzb2x2YWJpbGl0w6ksIG9uIGNhbGN1bGUgbGVzIHByb2JhYmlsaXTDqXMgc3RhdGlzdGlxdWVzIGTigJl1biBkw6lmYXV0IGRlIHBhaWVtZW50LgpMZSByYXBwb3J0IGRlIHNvbHZhYmlsaXTDqSBwZXV0IGNvbnRlbmlyIGRlcyB2YWxldXJzIGRlIHByb2JhYmlsaXTDqSAoc2NvcmVzKSBjYWxjdWzDqWVzIMOgIGzigJlhaWRlIGRlIG3DqXRob2RlcyBtYXRow6ltYXRpcXVlcyBldCBzdGF0aXN0aXF1ZXMgc2NpZW50aWZpcXVlbWVudCByZWNvbm51ZXMuIFBvdXIgw6dhLCBvbiBzZSBiYXNlIHN1ciB1biBncmFuZCBub21icmUgZGUgY3JpdMOocmVzLCBjb21tZSBsZXMgcmV2ZW51cywgbOKAmWFkcmVzc2UsIGxhIHByb2Zlc3Npb24sIGxhIHNpdHVhdGlvbiBmYW1pbGlhbGUgZXQgbOKAmWhpc3RvcmlxdWUgZGUgcGFpZW1lbnQsIHBvdXIgw6l2YWx1ZXIgbGUgcmlzcXVlIGZ1dHVyIGRlIGTDqWZhdXQgZGUgcGFpZW1lbnQgZHUgY2xpZW50LgpMZSByw6lzdWx0YXQgZXN0IGV4cHJpbcOpIHNvdXMgbGEgZm9ybWUgZOKAmXVuZSBub3RlIGRlIHNvbHZhYmlsaXTDqSAoYXBwZWzDqWUgwqsgc2NvcmUgwrspLgpMZXMgaW5mb3JtYXRpb25zIGFpbnNpIG9idGVudWVzIHNlcnZlbnQgZGUgYmFzZSDDoCBub3RyZSBkw6ljaXNpb24gY29uY2VybmFudCBsYSBjb25jbHVzaW9uLCBs4oCZZXjDqWN1dGlvbiBvdSBsYSByw6lzaWxpYXRpb24gZOKAmXVuZSByZWxhdGlvbiBjb250cmFjdHVlbGxlLgpTaSB0dSBlc3RpbWVzIGF2b2lyIMOpdMOpIGluanVzdGVtZW50IGV4Y2x1IGRlIGxhIGNvbmNsdXNpb24gZOKAmXVuIGNvbnRyYXQgZW4gcmFpc29uIGRlIGzigJnDqXZhbHVhdGlvbiBkZSBzb2x2YWJpbGl0w6ksIG7igJlow6lzaXRlIHBhcyDDoCBub3VzIGV4cGxpcXVlciB0b24gcG9pbnQgZGUgdnVlIHBhciBlLW1haWwuCk5vdXMgcsOpZXhhbWluZXJvbnMgYWxvcnMgbGEgZMOpY2lzaW9uIGF1dG9tYXRpc8OpZSBhdSBjYXMgcGFyIGNhcywgY29uZm9ybcOpbWVudCDDoCBs4oCZYXJ0aWNsZSAyMiwgcGFyYWdyYXBoZSAzLCBkdSBSR1BELgpBZmluIGRlIHBvdXZvaXIgZWZmZWN0dWVyIGxhIHbDqXJpZmljYXRpb24gZGUgc29sdmFiaWxpdMOpLCBub3VzIHNvbW1lcyBhdXRvcmlzw6lzLCBjb25mb3Jtw6ltZW50IMOgIGzigJlhcnRpY2xlIDYsIHBhcmFncmFwaGUgMSwgcG9pbnQgYiksIGR1IFJHUEQsIMOgIGVucmVnaXN0cmVyIGV0IMOgIHRyYWl0ZXIgdGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsLiAgICAgICAgPC9wPgo8cD5EYW5zIGxlIGNhZHJlIGR1IGNvbnRyYXQgZW4gY291cnMgZGUgbsOpZ29jaWF0aW9uLCBvbiB0cmFuc21ldCB0ZXMgZG9ubsOpZXMgYXV4IHByZXN0YXRhaXJlcyBzdWl2YW50cyBkYW5zIGxlcyBjYXMgw6ludW3DqXLDqXMgY2ktZGVzc291cyA6PC9wPgo8dWw+CjxsaT48aDMgaWQ9ImpzZWN0aW9uYXV0b21hdGlzY2hlaWRlbnRpdHRzdW5kYm9uaXR0c3ByZnVuZ2JlaWF1c3dhaGxkZXJ6YWhsdW5nc2FydHBheXBhbCI+VsOpcmlmaWNhdGlvbiBhdXRvbWF0aXF1ZSBkZSBsJ2lkZW50aXTDqSBldCBkZSBsYSBzb2x2YWJpbGl0w6kgbG9yc3F1ZSB0dSBjaG9pc2lzIGxlIG1vZGUgZGUgcGFpZW1lbnQgwqsgUGF5UGFsIMK7PC9oMz4KPHVsPgo8bGk+PGg0IGlkPSJqc2VjdGlvbndlbGNoZXBlcnNvbmVuYmV6b2dlbmVuZGF0ZW53ZXJkZW5lcmhvYmVudW5kaW53ZWxjaGVtdW1mYW5nd2VyZGVuZGllc2V2ZXJhcmJlaXRldC01Ij5RdWVsbGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIHNvbnQgY29sbGVjdMOpZXMgZXQgZGFucyBxdWVsbGUgbWVzdXJlIHNvbnQtZWxsZXMgdHJhaXTDqWVzID88L2g0Pgo8cD5TaSB0dSBhcyBjaG9pc2kgwqsgUGF5UGFsIMK7IGNvbW1lIG1vZGUgZGUgcGFpZW1lbnQsIG9uIHRyYW5zbWV0dHJhIHRlcyBkb25uw6llcyBwZXJzb25uZWxsZXMgY29sbGVjdMOpZXMgbG9ycyBkZSBsYSBjb21tYW5kZSDDoCBsYSBzb2Npw6l0w6kgUGF5UGFsIChFdXJvcGUpIFMuw6Agci5sLiBldCBDaWUsIFMuQy5BLiwgMjItMjQgQm91bGV2YXJkIFJveWFsLCBMLTI0NDkgTHV4ZW1ib3VyZyAoY2ktYXByw6hzIMKrIFBheVBhbCDCuykuClNpIHR1IGRvbm5lcyB0b24gYWNjb3JkLCBsZXMgZG9ubsOpZXMgc3VpdmFudGVzIHNvbnQgY29uY2VybsOpZXMgcGFyIGNlIHRyYW5zZmVydCA6CnByw6lub20gZXQgbm9tLCBydWUsIG51bcOpcm8sIGNvZGUgcG9zdGFsLCB2aWxsZSwgZGF0ZSBkZSBuYWlzc2FuY2UsIG51bcOpcm8gZGUgdMOpbMOpcGhvbmUgYWluc2kgcXVlIGxlcyBkb25uw6llcyBsacOpZXMgw6AgdGEgY29tbWFuZGUuPC9wPjwvbGk+CjxsaT48aDQgaWQ9ImpzZWN0aW9ucmVjaHRzZ3J1bmRsYWdlZnJkaWV2ZXJhcmJlaXR1bmdwZXJzb25lbmJlem9nZW5lcmRhdGVuLTUiPkJhc2UganVyaWRpcXVlIGR1IHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsPC9oND4KPHA+QXJ0LiA2LCBhbC4gMSwgbGV0LiBiIGR1IFJHUEQgKG1pc2UgZW4gxZN1dnJlIGRlIG1lc3VyZXMgKHByw6kpY29udHJhY3R1ZWxsZXMpPC9wPjwvbGk+CjxsaT48aDQgaWQ9ImpzZWN0aW9uendlY2tkZXJkYXRlbnZlcmFyYmVpdHVuZy01Ij5GaW5hbGl0w6kgZHUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXM8L2g0Pgo8cD5RdWFuZCB0dSBjaG9pc2lzIGxlIG1vZGUgZGUgcGFpZW1lbnQgwqsgUGF5UGFsIMK7LCBQYXlQYWwgZWZmZWN0dWUgdW5lIHbDqXJpZmljYXRpb24gZGUgc29sdmFiaWxpdMOpLgpQb3VyIMOnYSwgaWxzIHV0aWxpc2VudCBkZXMgbcOpdGhvZGVzIG1hdGjDqW1hdGlxdWVzIGV0IHN0YXRpc3RpcXVlcyBwb3VyIGNhbGN1bGVyIHVuZSBub3RlIGluZGlxdWFudCBsYSBwcm9iYWJpbGl0w6kgZCd1biBkw6lmYXV0IGRlIHBhaWVtZW50IChjZSBxdSdvbiBhcHBlbGxlIGxlIGNhbGN1bCBkJ3VuIHNjb3JlKS4KUGF5UGFsIHNlIGJhc2Ugc3VyIGxhIG5vdGUgZGUgc2NvcmluZyBjYWxjdWzDqWUgcG91ciBkw6ljaWRlciBzJ2lsIG1ldCDDoCBkaXNwb3NpdGlvbiBsZXMgbW9kZXMgZGUgcGFpZW1lbnQgY29uY2VybsOpcy4KTGUgY2FsY3VsIGQndW5lIG5vdGUgZGUgc2NvcmluZyBzJ2VmZmVjdHVlIHNlbG9uIGRlcyBtw6l0aG9kZXMgc2NpZW50aWZpcXVlcyByZWNvbm51ZXMuCk9uIHRlIHJlbnZvaWUgw6lnYWxlbWVudCDDoCBsYSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqSBkZSBQYXlQYWwgOiA8YSBocmVmPSJodHRwczovL3d3dy5wYXlwYWwuY29tL2RlL3dlYmFwcHMvbXBwL3VhL3ByaXZhY3ktZnVsbCIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly93d3cucGF5cGFsLmNvbS9kZS93ZWJhcHBzL21wcC91YS9wcml2YWN5LWZ1bGw8L2E+PC9wPjwvbGk+CjxsaT48aDQgaWQ9ImpzZWN0aW9uZGF1ZXJkZXJzcGVpY2hlcnVuZy01Ij5EdXLDqWUgZGUgY29uc2VydmF0aW9uPC9oND4KPHA+T24gdmEgY29uc2VydmVyIGxlcyBkb25uw6llcyBuw6ljZXNzYWlyZXMgYXUgdHJhaXRlbWVudCBkdSBwYWllbWVudCBhdXNzaSBsb25ndGVtcHMgcXVlIMOnYSBzZXJhIG7DqWNlc3NhaXJlIHBvdXIgbWVuZXIgw6AgYmllbiBsYSB0cmFuc2FjdGlvbi4KU2kgY2VzIGRvbm7DqWVzIHNvbnQgc291bWlzZXMgw6AgZGVzIG9ibGlnYXRpb25zIGzDqWdhbGVzIGRlIGNvbnNlcnZhdGlvbiwgZWxsZXMgc2Vyb250IHN1cHByaW3DqWVzIMOgIGwnZXhwaXJhdGlvbiBkZSBjZXR0ZSBvYmxpZ2F0aW9uLgpMYSBkdXLDqWUgZGUgY29uc2VydmF0aW9uIGRlcyBkb25uw6llcyBwYXIgUGF5UGFsIGVzdCBwcsOpY2lzw6llIGRhbnMgbGEgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kgZGUgUGF5UGFsIDogPGEgaHJlZj0iaHR0cHM6Ly93d3cucGF5cGFsLmNvbS9kZS93ZWJhcHBzL21wcC91YS9wcml2YWN5LWZ1bGwiIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPmh0dHBzOi8vd3d3LnBheXBhbC5jb20vZGUvd2ViYXBwcy9tcHAvdWEvcHJpdmFjeS1mdWxsPC9hPjwvcD48L2xpPgo8bGk+PGg0IGlkPSJqc2VjdGlvbndpZGVyc3BydWNoc3VuZGxzY2h1bmdzbWdsaWNoa2VpdC00Ij5Qb3NzaWJpbGl0w6kgZCdvcHBvc2l0aW9uIGV0IGRlIHJhZGlhdGlvbjwvaDQ+CjxwPlR1IHBldXggw6AgdG91dCBtb21lbnQgdCdvcHBvc2VyIGF1IHRyYWl0ZW1lbnQgZGUgdGVzIGRvbm7DqWVzIGNvbmZvcm3DqW1lbnQgw6AgbCdhcnRpY2xlIDIxIGR1IFJHUEQgZXQgZGVtYW5kZXIgbGV1ciBlZmZhY2VtZW50IGNvbmZvcm3DqW1lbnQgw6AgbCdhcnRpY2xlIDE3IGR1IFJHUEQuClR1IHRyb3V2ZXJhcyBlbiBiYXMgZGUgY2V0dGUgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kgbGEgbGlzdGUgZGUgdGVzIGRyb2l0cyBldCBsYSBtYXJjaGUgw6Agc3VpdnJlIHBvdXIgbGVzIGZhaXJlIHZhbG9pci4gIDwvcD48L2xpPjwvdWw+PC9saT4KPC91bD4KPGgyIGlkPSJqc2VjdGlvbnN0YXRpc3Rpc2NoZWF1c3dlcnR1bmdkZXJiZXN1Y2hlZGllc2VyaW50ZXJuZXRzZWl0ZXdlYnRyYWNrZXIiPkFuYWx5c2Ugc3RhdGlzdGlxdWUgZGVzIHZpc2l0ZXMgc3VyIGNlIHNpdGUgd2ViIC0gV2VidHJhY2tlcjwvaDI+CjxwPkxvcnMgZGUgbGEgY29uc3VsdGF0aW9uIGRlIGNlIHNpdGUgSW50ZXJuZXQgb3UgZGUgY2VydGFpbnMgZmljaGllcnMgZHUgc2l0ZSwgb24gY29sbGVjdGUsIHRyYWl0ZSBldCBzdG9ja2UgbGVzIGRvbm7DqWVzIHN1aXZhbnRlcyA6CmFkcmVzc2UgSVAsIHNpdGUgd2ViIMOgIHBhcnRpciBkdXF1ZWwgbGUgZmljaGllciBhIMOpdMOpIGNvbnN1bHTDqSwgbm9tIGR1IGZpY2hpZXIsIGRhdGUgZXQgaGV1cmUgZGUgbGEgY29uc3VsdGF0aW9uLCB2b2x1bWUgZGUgZG9ubsOpZXMgdHJhbnNmw6lyw6llcyBldCBpbmRpY2F0aW9uIGRlIGxhIHLDqXVzc2l0ZSBkZSBsYSBjb25zdWx0YXRpb24gKGNlIHF1J29uIGFwcGVsbGUgdW4gwqsgam91cm5hbCB3ZWIgwrspLgpPbiB1dGlsaXNlIGNlcyBkb25uw6llcyBkJ2FjY8OocyBleGNsdXNpdmVtZW50IHNvdXMgZm9ybWUgbm9uIHBlcnNvbm5hbGlzw6llIHBvdXIgYW3DqWxpb3JlciBlbiBwZXJtYW5lbmNlIG5vdHJlIHNpdGUgZXQgw6AgZGVzIGZpbnMgc3RhdGlzdGlxdWVzLgpPbiB1dGlsaXNlIMOpZ2FsZW1lbnQgbGVzIG91dGlscyBkZSBzdWl2aSB3ZWIgc3VpdmFudHMgcG91ciBhbmFseXNlciBsZXMgdmlzaXRlcyBzdXIgY2Ugc2l0ZSA6PC9wPgo8dWw+CjxsaT48aDMgaWQ9ImpzZWN0aW9uYW5hbWV0cmFja2VyMTAyYWdvb2dsZSI+PGEgbmFtZT0idHJhY2tlci0xMDIiPjwvYT4gIEdvb2dsZTwvaDM+CjxwPlN1ciBub3RyZSBzaXRlLCBvbiB1dGlsaXNlIGxlIHNlcnZpY2UgR29vZ2xlIGRlIGxhIHNvY2nDqXTDqSBHb29nbGUgSXJlbGFuZCBMaW1pdGVkLCBHb3Jkb24gSG91c2UsIEJhcnJvdyBTdHJlZXQsIDQgRHVibGluLCBJcmxhbmRlLCBlLW1haWwgOiA8YSBocmVmPSJtYWlsdG86c3VwcG9ydC1kZXV0c2NobGFuZEBnb29nbGUuY29tIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5zdXBwb3J0LWRldXRzY2hsYW5kQGdvb2dsZS5jb208L2E+LCBzaXRlIHdlYiA6IDxhIGhyZWY9Imh0dHBzOi8vd3d3Lmdvb2dsZS5jb20vIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL3d3dy5nb29nbGUuY29tLzwvYT4uCkxlcyBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCBzb250IMOpZ2FsZW1lbnQgdHJhbnNmw6lyw6llcyB2ZXJzIGxlcyDDiXRhdHMtVW5pcy4KRW4gY2UgcXVpIGNvbmNlcm5lIGxlIHRyYW5zZmVydCBkZSBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCB2ZXJzIGxlcyDDiXRhdHMtVW5pcywgaWwgZXhpc3RlIHVuZSBkw6ljaXNpb24gZCdhZMOpcXVhdGlvbiByZWxhdGl2ZSBhdSBjYWRyZSBkZSBwcm90ZWN0aW9uIGRlcyBkb25uw6llcyBVRS3DiXRhdHMtVW5pcyAoRVUtVVMgRGF0YSBQcml2YWN5IEZyYW1ld29yaykgZGUgbGEgQ29tbWlzc2lvbiBldXJvcMOpZW5uZSBhdSBzZW5zIGRlIGwnYXJ0aWNsZSA0NSBkdSBSR1BEIChjaS1hcHLDqHMgOiBEUEYgLSA8YSBocmVmPSJodHRwczovL2NvbW1pc3Npb24uZXVyb3BhLmV1L2RvY3VtZW50L2ZhMDljYmFkLWRkN2QtNDY4NC1hZTYwLWJlMDNmY2IwZmRkZl9lbiIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly9jb21taXNzaW9uLmV1cm9wYS5ldS9kb2N1bWVudC9mYTA5Y2JhZC1kZDdkLTQ2ODQtYWU2MC1iZTAzZmNiMGZkZGZfZW48L2E+ICkuCkwnZXhwbG9pdGFudCBkdSBzZXJ2aWNlIGVzdCBjZXJ0aWZpw6kgZGFucyBsZSBjYWRyZSBkdSBEUEYsIGNlIHF1aSBzaWduaWZpZSBxdWUgbGUgbml2ZWF1IGRlIHByb3RlY3Rpb24gaGFiaXR1ZWwgcHLDqXZ1IHBhciBsZSBSR1BEIHMnYXBwbGlxdWUgw6AgY2UgdHJhbnNmZXJ0LjwvcD4KPHA+TGEgYmFzZSBqdXJpZGlxdWUgZHUgdHJhaXRlbWVudCBkZSB0ZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgZXN0IHRvbiBjb25zZW50ZW1lbnQsIGNvbmZvcm3DqW1lbnQgw6AgbCdhcnRpY2xlIDYsIHBhcmFncmFwaGUgMSwgcG9pbnQgYSkgZHUgUkdQRCBvdSDDoCBsJ2FydGljbGUgOSwgcGFyYWdyYXBoZSAyLCBwb2ludCBhKSBkdSBSR1BELCBxdWUgdHUgYXMgZG9ubsOpIHN1ciBub3RyZSBzaXRlIEludGVybmV0LiAgICAgPC9wPgo8cD5PbiB1dGlsaXNlIEdvb2dsZSBwb3VyIHBvdXZvaXIgY2hhcmdlciBkJ2F1dHJlcyBzZXJ2aWNlcyBHb29nbGUgc3VyIGxlIHNpdGUgd2ViLiBDZSBzZXJ2aWNlIHNlcnQgw6AgZm91cm5pciBkJ2F1dHJlcyBzZXJ2aWNlcyBHb29nbGUsIGNvbW1lIHBhciBleGVtcGxlIGxlIHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzIG7DqWNlc3NhaXJlcyDDoCBsYSBtaXNlIMOgIGRpc3Bvc2l0aW9uIGRlIGZsdXggZXQgZGUgcG9saWNlcyBkZSBjYXJhY3TDqHJlcywgYWluc2kgcXVlIGRlcyBjb250ZW51cyBwZXJ0aW5lbnRzIGlzc3VzIGRlIGxhIHJlY2hlcmNoZSBHb29nbGUuIElsIGVzdCB0ZWNobmlxdWVtZW50IG7DqWNlc3NhaXJlIHBvdXIgw6ljaGFuZ2VyIGVudHJlIGxlcyBzZXJ2aWNlcyBHb29nbGUgbGVzIGluZm9ybWF0aW9ucyBkb250IEdvb2dsZSBkaXNwb3NlIGTDqWrDoCBzdXIgbGUgdmlzaXRldXIgZHUgc2l0ZSBldCBwb3VyIHBvdXZvaXIgbHVpIHByb3Bvc2VyIGRlcyBjb250ZW51cyBwZXJzb25uYWxpc8OpcyBlbiBmb25jdGlvbiBkZSBzb24gY29tcHRlIEdvb2dsZS4gIDwvcD4KPHA+UG91ciBsZSB0cmFpdGVtZW50IGx1aS1tw6ptZSwgbGUgc2VydmljZSBvdSBub3VzLW3Dqm1lcyBjb2xsZWN0b25zIGxlcyBkb25uw6llcyBzdWl2YW50ZXMgOgpsZXMgZG9ubsOpZXMgZGUgZm9uZCBlbnJlZ2lzdHLDqWVzIGRhbnMgbGUgY29tcHRlIEdvb2dsZSBvdSBzdXIgZOKAmWF1dHJlcyBzZXJ2aWNlcyBHb29nbGUgY29uY2VybmFudCBsZSB2aXNpdGV1ciBkdSBzaXRlLCBsZXMgZG9ubsOpZXMgZGUgZm9uZCBuw6ljZXNzYWlyZXMgw6AgbGEgZm91cm5pdHVyZSBkZXMgc2VydmljZXMgR29vZ2xlLCBjb21tZSBwYXIgZXhlbXBsZSBsZXMgZG9ubsOpZXMgZGUgc3RyZWFtaW5nIG91IHB1YmxpY2l0YWlyZXMsIGxlcyBkb25uw6llcyBzdXIgbOKAmXV0aWxpc2F0aW9uIGRlIGxhIHJlY2hlcmNoZSBHb29nbGUgcGFyIGzigJl1dGlsaXNhdGV1ciBkdSBzaXRlLCBkZXMgaW5mb3JtYXRpb25zIHN1ciBsJ2FwcGFyZWlsIHV0aWxpc8OpLCBsJ2FkcmVzc2UgSVAgZXQgbGUgbmF2aWdhdGV1ciBkZSBsJ3V0aWxpc2F0ZXVyLCBhaW5zaSBxdWUgZCdhdXRyZXMgZG9ubsOpZXMgcHJvdmVuYW50IGRlcyBzZXJ2aWNlcyBHb29nbGUgbsOpY2Vzc2FpcmVzIMOgIGxhIGZvdXJuaXR1cmUgZGUgY2VzIHNlcnZpY2VzIGVuIGxpZW4gYXZlYyBub3RyZSBzaXRlIHdlYi48L3A+CjxwPlNpIGxlIHNlcnZpY2UgZXN0IGFjdGl2w6kgc3VyIG5vdHJlIHNpdGUgd2ViLCBjZWx1aS1jaSDDqXRhYmxpdCB1bmUgY29ubmV4aW9uIGF2ZWMgbGVzIHNlcnZldXJzIGRlIGxhIHNvY2nDqXTDqSBHb29nbGUgSXJlbGFuZCBMaW1pdGVkIGV0IHRyYW5zbWV0IGxlcyBkb25uw6llcyBuw6ljZXNzYWlyZXMuIERhbnMgbGUgY2FkcmUgZHUgdHJhaXRlbWVudCBkZXMgY29tbWFuZGVzLCBpbCBwZXV0IMOpZ2FsZW1lbnQgeSBhdm9pciB1biB0cmFuc2ZlcnQgZGUgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgdmVycyBsZXMgc2VydmV1cnMgZGUgbGEgc29jacOpdMOpIEdvb2dsZSBMTEMsIDE2MDAgQW1waGl0aGVhdHJlIFBhcmt3YXksIDk0MDQzIE1vdW50YWluIFZpZXcsIMOJdGF0cy1VbmlzLiAgIAoKTG9yc3F1ZSB0dSB1dGlsaXNlcyBsZSBzZXJ2aWNlIEdvb2dsZSBzdXIgbm90cmUgc2l0ZSB3ZWIsIEdvb2dsZSBwZXV0LCBsZSBjYXMgw6ljaMOpYW50LCByZWNldm9pciBldCB0cmFpdGVyIGRlcyBpbmZvcm1hdGlvbnMgcHJvdmVuYW50IGQnYXV0cmVzIHNlcnZpY2VzIEdvb2dsZSBhZmluIGRlIGZvdXJuaXIgZGVzIHNlcnZpY2VzIGVuIGFycmnDqHJlLXBsYW4gcG91ciBsJ2FmZmljaGFnZSBldCBsZSB0cmFpdGVtZW50IGRlcyBkb25uw6llcyBkZXMgc2VydmljZXMgcHJvcG9zw6lzIHBhciBHb29nbGUuIMOAIGNldHRlIGZpbiwgaWwgcGV1dCDDqWdhbGVtZW50IHkgYXZvaXIgdW4gdHJhbnNmZXJ0IGRlIGRvbm7DqWVzIHZlcnMgbGVzIHNlcnZpY2VzIEdvb2dsZSBzdWl2YW50cyA6IEdvb2dsZSBBUElzLCBEb3VibGVDbGljaywgR29vZ2xlIENsb3VkLCBHb29nbGUgQWRzIGV0IEdvb2dsZSBGb250cywgY29uZm9ybcOpbWVudCDDoCBsYSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqSBkZSBHb29nbGUuIAoKClR1IHBldXggY29uc3VsdGVyIGxhIGNlcnRpZmljYXRpb24gZHUgcHJlc3RhdGFpcmUgZGFucyBsZSBjYWRyZSBkdSBjYWRyZSBkZSBwcm90ZWN0aW9uIGRlcyBkb25uw6llcyBVRS3DiXRhdHMtVW5pcyDDoCBsJ2FkcmVzc2UgPGEgaHJlZj0iaHR0cHM6Ly93d3cuZGF0YXByaXZhY3lmcmFtZXdvcmsuZ292L2xpc3QiIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPmh0dHBzOi8vd3d3LmRhdGFwcml2YWN5ZnJhbWV3b3JrLmdvdi9saXN0PC9hPi48L3A+CjxwPlR1IHBldXggcmV0aXJlciB0b24gY29uc2VudGVtZW50IMOgIHRvdXQgbW9tZW50LgpUdSB0cm91dmVyYXMgcGx1cyBkJ2luZm9ybWF0aW9ucyBzdXIgbGUgcmV0cmFpdCBkZSB0b24gY29uc2VudGVtZW50IHNvaXQgZGFucyBsZSBmb3JtdWxhaXJlIGRlIGNvbnNlbnRlbWVudCBsdWktbcOqbWUsIHNvaXQgw6AgbGEgZmluIGRlIGxhIHByw6lzZW50ZSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqS48L3A+CjxwPlBvdXIgcGx1cyBkJ2luZm9ybWF0aW9ucyBzdXIgbGUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgdHJhbnNtaXNlcywgY29uc3VsdGUgbGEgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kgZHUgZm91cm5pc3NldXIgw6AgbCdhZHJlc3NlIDxhIGhyZWY9Imh0dHBzOi8vcG9saWNpZXMuZ29vZ2xlLmNvbS9wcml2YWN5IiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL3BvbGljaWVzLmdvb2dsZS5jb20vcHJpdmFjeTwvYT4uPC9wPgo8cD5MZSBmb3Vybmlzc2V1ciBwcm9wb3NlIMOpZ2FsZW1lbnQgdW5lIG9wdGlvbiBkZSBkw6lzaW5zY3JpcHRpb24gc3VyIDxhIGhyZWY9Imh0dHBzOi8vc3VwcG9ydC5nb29nbGUuY29tL015LUFkLUNlbnRlci1IZWxwL2Fuc3dlci8xMjE1NTQ1MT9obD1kZSIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly9zdXBwb3J0Lmdvb2dsZS5jb20vTXktQWQtQ2VudGVyLUhlbHAvYW5zd2VyLzEyMTU1NDUxP2hsPWRlPC9hPi48L3A+PC9saT4KPGxpPjxoMyBpZD0ianNlY3Rpb25hbmFtZXRyYWNrZXI0MTdhZ29vZ2xlYWRzIj48YSBuYW1lPSJ0cmFja2VyLTQxNyI+PC9hPiAgR29vZ2xlIEFkczwvaDM+CjxwPlN1ciBub3RyZSBzaXRlLCBvbiB1dGlsaXNlIGxlIHNlcnZpY2UgR29vZ2xlIEFkcyBkZSBsYSBzb2Npw6l0w6kgR29vZ2xlIElyZWxhbmQgTGltaXRlZCwgR29yZG9uIEhvdXNlLCBCYXJyb3cgU3RyZWV0LCA0IER1YmxpbiwgSXJsYW5kZSwgZS1tYWlsIDogPGEgaHJlZj0ibWFpbHRvOnN1cHBvcnQtZGV1dHNjaGxhbmRAZ29vZ2xlLmNvbSIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+c3VwcG9ydC1kZXV0c2NobGFuZEBnb29nbGUuY29tPC9hPiwgc2l0ZSB3ZWIgOiA8YSBocmVmPSJodHRwczovL3d3dy5nb29nbGUuY29tLyIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS88L2E+LgpMZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgc29udCDDqWdhbGVtZW50IHRyYW5zZsOpcsOpZXMgdmVycyBsZXMgw4l0YXRzLVVuaXMuCkVuIGNlIHF1aSBjb25jZXJuZSBsZSB0cmFuc2ZlcnQgZGUgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgdmVycyBsZXMgw4l0YXRzLVVuaXMsIGlsIGV4aXN0ZSB1bmUgZMOpY2lzaW9uIGQnYWTDqXF1YXRpb24gcmVsYXRpdmUgYXUgY2FkcmUgZGUgcHJvdGVjdGlvbiBkZXMgZG9ubsOpZXMgVUUtw4l0YXRzLVVuaXMgKEVVLVVTIERhdGEgUHJpdmFjeSBGcmFtZXdvcmspIGRlIGxhIENvbW1pc3Npb24gZXVyb3DDqWVubmUsIGF1IHNlbnMgZGUgbCdhcnRpY2xlIDQ1IGR1IFJHUEQgKGNpLWFwcsOocyA6IERQRiAtIDxhIGhyZWY9Imh0dHBzOi8vY29tbWlzc2lvbi5ldXJvcGEuZXUvZG9jdW1lbnQvZmEwOWNiYWQtZGQ3ZC00Njg0LWFlNjAtYmUwM2ZjYjBmZGRmX2VuIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL2NvbW1pc3Npb24uZXVyb3BhLmV1L2RvY3VtZW50L2ZhMDljYmFkLWRkN2QtNDY4NC1hZTYwLWJlMDNmY2IwZmRkZl9lbjwvYT4gKS4KTCdleHBsb2l0YW50IGR1IHNlcnZpY2UgZXN0IGNlcnRpZmnDqSBkYW5zIGxlIGNhZHJlIGR1IERQRiwgY2UgcXVpIHNpZ25pZmllIHF1ZSBsZSBuaXZlYXUgZGUgcHJvdGVjdGlvbiBoYWJpdHVlbCBwcsOpdnUgcGFyIGxlIFJHUEQgcydhcHBsaXF1ZSDDoCBjZSB0cmFuc2ZlcnQuPC9wPgo8cD5MYSBiYXNlIGp1cmlkaXF1ZSBkdSB0cmFpdGVtZW50IGRlIHRlcyBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCBlc3QgdG9uIGNvbnNlbnRlbWVudCwgY29uZm9ybcOpbWVudCDDoCBsJ2FydGljbGUgNiwgcGFyYWdyYXBoZSAxLCBwb2ludCBhKSBkdSBSR1BEIG91IMOgIGwnYXJ0aWNsZSA5LCBwYXJhZ3JhcGhlIDIsIHBvaW50IGEpIGR1IFJHUEQsIHF1ZSB0dSBhcyBkb25uw6kgc3VyIG5vdHJlIHNpdGUgd2ViLiAgICAgPC9wPgo8cD5Hb29nbGUgQWRzIGVzdCB1biBzeXN0w6htZSBwdWJsaWNpdGFpcmUgcXVpIG5vdXMgcGVybWV0IGRlIGRpZmZ1c2VyIGRlcyBhbm5vbmNlcyBwdWJsaWNpdGFpcmVzIHN1ciBkZXMgc2l0ZXMgd2ViIGV4dGVybmVzIGFmaW4gZCdpbmZvcm1lciBub3MgY2xpZW50cyBkZSBub3Mgc2VydmljZXMuIEVuIGZvbmN0aW9uIGRlcyBwYXJhbcOodHJlcyBxdWUgbm91cyBhdm9ucyBkw6lmaW5pcywgR29vZ2xlIEFkcyBhZmZpY2hlIHN1ciBjZXMgc2l0ZXMgd2ViIGRlcyBwdWJsaWNpdMOpcyBwZXJzb25uYWxpc8OpZXMgZW4gZm9uY3Rpb24gZGUgbm90cmUgY2xpZW50w6hsZSwgcXVpIHJlZGlyaWdlbnQgdmVycyBub3RyZSBzaXRlIHdlYi4gU2kgbGUgdmlzaXRldXIgY2xpcXVlIHN1ciB1bmUgYW5ub25jZSBHb29nbGUgQWRzLCBpbCBlc3QgcmVkaXJpZ8OpIHZlcnMgbm90cmUgc2l0ZSB3ZWIuIFBvdXIgw6l2YWx1ZXIgbCdlZmZpY2FjaXTDqSBkZXMgYW5ub25jZXMgR29vZ2xlIEFkcyBldCBjYWxjdWxlciBsYSByw6ltdW7DqXJhdGlvbiBjb3JyZXNwb25kYW50ZSwgR29vZ2xlIEFkcyBlZmZlY3R1ZSB1bmUgbWVzdXJlIGRlIGwnZWZmaWNhY2l0w6kgZGUgbGEgY2FtcGFnbmUgcHVibGljaXRhaXJlIGxvcnNxdWUgbm90cmUgc2l0ZSB3ZWIgZXN0IGNvbnN1bHTDqS4gTm90cmUgc2l0ZSB3ZWIgdHJhaXRlIGxlcyBkb25uw6llcyBmb3VybmllcyBwYXIgR29vZ2xlIEFkcyBwb3VyIHBvdXZvaXIgYW5hbHlzZXIgZXQgYW3DqWxpb3JlciBub3MgY2FtcGFnbmVzIHB1YmxpY2l0YWlyZXMsIGFpbnNpIHF1ZSBwb3VyIGNhbGN1bGVyIGxhIHLDqW11bsOpcmF0aW9uIMOpdmVudHVlbGxlLiAgICAKClNpIHR1IGRvbm5lcyB0b24gYWNjb3JkLCB0ZXMgZG9ubsOpZXMgcG91cnJvbnQgw6l2ZW50dWVsbGVtZW50IMOqdHJlIHV0aWxpc8OpZXMgw6AgZGVzIGZpbnMgZGUgcmVtYXJrZXRpbmcuPC9wPgo8cD5Qb3VyIGxlIHRyYWl0ZW1lbnQgbHVpLW3Dqm1lLCBsZSBzZXJ2aWNlIG91IG5vdXMtbcOqbWVzIGNvbGxlY3RvbnMgbGVzIGRvbm7DqWVzIHN1aXZhbnRlcyA6CmRlcyBkb25uw6llcyBzdXIgbGVzIGNlbnRyZXMgZCdpbnTDqXLDqnQgcHVibGljaXRhaXJlcyBkZXMgdmlzaXRldXJzIGR1IHNpdGUsIGxlcyBpbnRlcmFjdGlvbnMgZGVzIHZpc2l0ZXVycyBhdmVjIGxlcyBwdWJsaWNpdMOpcyBsacOpZXMgw6Agbm90cmUgc2l0ZSB3ZWIsIGRlcyBkb25uw6llcyBzdXIgbGVzIHZpc2l0ZXMgZGUgbm90cmUgc2l0ZSB3ZWIgcGFyIGRlcyB2aXNpdGV1cnMgcXVpIG9udCBwcsOpYWxhYmxlbWVudCBjbGlxdcOpIHN1ciB1bmUgcHVibGljaXTDqSBHb29nbGUgQWRzIGV0IG9udCBhaW5zaSBhY2PDqWTDqSDDoCBub3RyZSBzaXRlIHdlYiwgZGVzIGRvbm7DqWVzIHN1ciBsJ2FwcGFyZWlsIHV0aWxpc8OpLCBsJ2FkcmVzc2UgSVAgZXQgbGUgbmF2aWdhdGV1ciBkZSBsJ3V0aWxpc2F0ZXVyLCBhaW5zaSBxdWUgZCdhdXRyZXMgZG9ubsOpZXMgcHJvdmVuYW50IGRlcyBzZXJ2aWNlcyBHb29nbGUgcG91ciBsYSBtaXNlIMOgIGRpc3Bvc2l0aW9uIGV0IGwnb3B0aW1pc2F0aW9uIGRlcyBwdWJsaWNpdMOpcyBHb29nbGUgbGnDqWVzIMOgIG5vdHJlIHNpdGUgd2ViLjwvcD4KPHA+ClNpIGxlIHNlcnZpY2UgZXN0IGFjdGl2w6kgc3VyIG5vdHJlIHNpdGUgd2ViLCBjZWx1aS1jaSDDqXRhYmxpdCB1bmUgY29ubmV4aW9uIGF2ZWMgbGVzIHNlcnZldXJzIGRlIGxhIHNvY2nDqXTDqSBHb29nbGUgSXJlbGFuZCBMaW1pdGVkIGV0IHRyYW5zbWV0IGxlcyBkb25uw6llcyBuw6ljZXNzYWlyZXMuIERhbnMgbGUgY2FkcmUgZHUgdHJhaXRlbWVudCBkZXMgY29tbWFuZGVzLCBpbCBwZXV0IMOpZ2FsZW1lbnQgeSBhdm9pciB1biB0cmFuc2ZlcnQgZGUgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgdmVycyBsZXMgc2VydmV1cnMgZGUgbGEgc29jacOpdMOpIEdvb2dsZSBMTEMsIDE2MDAgQW1waGl0aGVhdHJlIFBhcmt3YXksIDk0MDQzIE1vdW50YWluIFZpZXcsIMOJdGF0cy1VbmlzLiAgIAoKTG9yc3F1ZSBub3VzIHV0aWxpc29ucyBHb29nbGUgQWRzIHN1ciBub3RyZSBzaXRlIHdlYiwgR29vZ2xlIHBldXQgdHJhbnNtZXR0cmUgZXQgdHJhaXRlciBkZXMgaW5mb3JtYXRpb25zIHByb3ZlbmFudCBkJ2F1dHJlcyBzZXJ2aWNlcyBHb29nbGUgYWZpbiBkZSBmb3VybmlyIGRlcyBzZXJ2aWNlcyBlbiBhcnJpw6hyZS1wbGFuIHZpc2FudCDDoCBhbcOpbGlvcmVyIGV0IMOgIHBlcnNvbm5hbGlzZXIgbGEgcHVibGljaXTDqSBHb29nbGUuIMOAIGNldHRlIGZpbiwgZCdhdXRyZXMgc2VydmljZXMgR29vZ2xlLCB0ZWxzIHF1ZSBHb29nbGUgQVBJcywgR29vZ2xlIENsb3VkLCBHb29nbGUgQWRzLCBHb29nbGUgQW5hbHl0aWNzLCBHb29nbGUgVGFnIE1hbmFnZXIsIEdvb2dsZSBNYXJrZXRpbmcgUGxhdGZvcm0gZXQgR29vZ2xlIEZvbnRzLCBwZXV2ZW50IMOpZ2FsZW1lbnQgdHJhaXRlciBkZXMgZG9ubsOpZXMgY29uZm9ybcOpbWVudCDDoCBsYSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqSBkZSBHb29nbGUsIHNvdXMgbGEgcmVzcG9uc2FiaWxpdMOpIGRlIEdvb2dsZSBlbiBtYXRpw6hyZSBkZSBwcm90ZWN0aW9uIGRlcyBkb25uw6llcy4gCgpUdSBwZXV4IGNvbnN1bHRlciBsYSBjZXJ0aWZpY2F0aW9uIGR1IHByZXN0YXRhaXJlIGRhbnMgbGUgY2FkcmUgZHUgY2FkcmUgZGUgcHJvdGVjdGlvbiBkZXMgZG9ubsOpZXMgVUUtw4l0YXRzLVVuaXMgw6AgbCdhZHJlc3NlIDxhIGhyZWY9Imh0dHBzOi8vd3d3LmRhdGFwcml2YWN5ZnJhbWV3b3JrLmdvdi9saXN0IiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL3d3dy5kYXRhcHJpdmFjeWZyYW1ld29yay5nb3YvbGlzdDwvYT4uCgpQb3VyIHBsdXMgZCdpbmZvcm1hdGlvbnMgc3VyIGxhIGdlc3Rpb24gcmVzcG9uc2FibGUgZGVzIGRvbm7DqWVzIGQnZW50cmVwcmlzZSwgcmVuZHMtdG9pIHN1ciA8YSBocmVmPSJodHRwczovL2J1c2luZXNzLnNhZmV0eS5nb29nbGUvcHJpdmFjeS8iIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPmh0dHBzOi8vYnVzaW5lc3Muc2FmZXR5Lmdvb2dsZS9wcml2YWN5LzwvYT4uICA8L3A+CjxwPlR1IHBldXggcmV0aXJlciB0b24gY29uc2VudGVtZW50IMOgIHRvdXQgbW9tZW50LgpUdSB0cm91dmVyYXMgcGx1cyBkJ2luZm9ybWF0aW9ucyBzdXIgbGUgcmV0cmFpdCBkZSB0b24gY29uc2VudGVtZW50IHNvaXQgZGFucyBsZSBmb3JtdWxhaXJlIGRlIGNvbnNlbnRlbWVudCBsdWktbcOqbWUsIHNvaXQgw6AgbGEgZmluIGRlIGxhIHByw6lzZW50ZSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqS48L3A+CjxwPlBvdXIgcGx1cyBkJ2luZm9ybWF0aW9ucyBzdXIgbGUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgdHJhbnNtaXNlcywgY29uc3VsdGUgbGEgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kgZHUgZm91cm5pc3NldXIgw6AgbCdhZHJlc3NlIDxhIGhyZWY9Imh0dHBzOi8vcG9saWNpZXMuZ29vZ2xlLmNvbS9wcml2YWN5IiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL3BvbGljaWVzLmdvb2dsZS5jb20vcHJpdmFjeTwvYT4uPC9wPgo8cD5MZSBmb3Vybmlzc2V1ciBwcm9wb3NlIMOpZ2FsZW1lbnQgdW5lIG9wdGlvbiBkZSBkw6lzaW5zY3JpcHRpb24gc3VyIDxhIGhyZWY9Imh0dHBzOi8vc3VwcG9ydC5nb29nbGUuY29tL015LUFkLUNlbnRlci1IZWxwL2Fuc3dlci8xMjE1NTQ1MT9obD1kZSIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly9zdXBwb3J0Lmdvb2dsZS5jb20vTXktQWQtQ2VudGVyLUhlbHAvYW5zd2VyLzEyMTU1NDUxP2hsPWRlPC9hPi48L3A+PC9saT4KPGxpPjxoMyBpZD0ianNlY3Rpb25hbmFtZXRyYWNrZXI0MThhZ29vZ2xlYW5hbHl0aWNzIj48YSBuYW1lPSJ0cmFja2VyLTQxOCI+PC9hPiAgR29vZ2xlIEFuYWx5dGljczwvaDM+CjxwPlN1ciBub3RyZSBzaXRlLCBvbiB1dGlsaXNlIGxlIHNlcnZpY2UgR29vZ2xlIEFuYWx5dGljcyBkZSBsYSBzb2Npw6l0w6kgR29vZ2xlIElyZWxhbmQgTHRkLiwgR29yZG9uIEhvdXNlLCBCYXJyb3cgU3RyZWV0LCA0IER1YmxpbiwgSXJsYW5kZSwgZS1tYWlsIDogPGEgaHJlZj0ibWFpbHRvOnN1cHBvcnQtZGV1dHNjaGxhbmRAZ29vZ2xlLmNvbSIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+c3VwcG9ydC1kZXV0c2NobGFuZEBnb29nbGUuY29tPC9hPiwgc2l0ZSB3ZWIgOiA8YSBocmVmPSJodHRwczovL3d3dy5nb29nbGUuY29tLyIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS88L2E+LgpMZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgc29udCDDqWdhbGVtZW50IHRyYW5zZsOpcsOpZXMgdmVycyBsZXMgw4l0YXRzLVVuaXMuCkVuIGNlIHF1aSBjb25jZXJuZSBsZSB0cmFuc2ZlcnQgZGUgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgdmVycyBsZXMgw4l0YXRzLVVuaXMsIGlsIGV4aXN0ZSB1bmUgZMOpY2lzaW9uIGQnYWTDqXF1YXRpb24gcmVsYXRpdmUgYXUgY2FkcmUgZGUgcHJvdGVjdGlvbiBkZXMgZG9ubsOpZXMgVUUtw4l0YXRzLVVuaXMgKEVVLVVTIERhdGEgUHJpdmFjeSBGcmFtZXdvcmspIGRlIGxhIENvbW1pc3Npb24gZXVyb3DDqWVubmUsIGF1IHNlbnMgZGUgbCdhcnRpY2xlIDQ1IGR1IFJHUEQgKGNpLWFwcsOocyA6IERQRiAtIDxhIGhyZWY9Imh0dHBzOi8vY29tbWlzc2lvbi5ldXJvcGEuZXUvZG9jdW1lbnQvZmEwOWNiYWQtZGQ3ZC00Njg0LWFlNjAtYmUwM2ZjYjBmZGRmX2VuIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL2NvbW1pc3Npb24uZXVyb3BhLmV1L2RvY3VtZW50L2ZhMDljYmFkLWRkN2QtNDY4NC1hZTYwLWJlMDNmY2IwZmRkZl9lbjwvYT4gKS4KTCdleHBsb2l0YW50IGR1IHNlcnZpY2UgZXN0IGNlcnRpZmnDqSBkYW5zIGxlIGNhZHJlIGR1IERQRiwgY2UgcXVpIHNpZ25pZmllIHF1ZSBsZSBuaXZlYXUgZGUgcHJvdGVjdGlvbiBoYWJpdHVlbCBwcsOpdnUgcGFyIGxlIFJHUEQgcydhcHBsaXF1ZSDDoCBjZSB0cmFuc2ZlcnQuPC9wPgo8cD5MYSBiYXNlIGp1cmlkaXF1ZSBkdSB0cmFpdGVtZW50IGRlIHRlcyBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCBlc3QgdG9uIGNvbnNlbnRlbWVudCwgY29uZm9ybcOpbWVudCDDoCBsJ2FydGljbGUgNiwgcGFyYWdyYXBoZSAxLCBwb2ludCBhKSwgZHUgUkdQRCBvdSDDoCBsJ2FydGljbGUgOSwgcGFyYWdyYXBoZSAyLCBwb2ludCBhKSwgZHUgUkdQRCwgcXVlIHR1IGFzIGRvbm7DqSBzdXIgbm90cmUgc2l0ZSBJbnRlcm5ldC4gICAgIDwvcD4KPHA+R29vZ2xlIEFuYWx5dGljcyBlc3QgdW4gb3V0aWwgZGUgc3VpdmkgcXVpIGFuYWx5c2UgbGUgY29tcG9ydGVtZW50IGRlcyB2aXNpdGV1cnMgZXQgbGV1cnMgaW50ZXJhY3Rpb25zIGF2ZWMgbm90cmUgc2l0ZSB3ZWIsIGV0IHF1aSBub3VzIGZvdXJuaXQgZGVzIGFuYWx5c2VzIGV0IGRlcyBwcsOpdmlzaW9ucyBzdXIgbGVzIGNvbnRlbnVzIGV0IGxlcyBwcm9kdWl0cyBkZSBub3RyZSBzaXRlIGFpbnNpIHF1ZSBzdXIgbGV1ciBwb3B1bGFyaXTDqSAoY2UgcXUnb24gYXBwZWxsZSBsZSDCqyBzdWl2aSDCuykuICAKCk9uIGEgaW50w6lncsOpIEdvb2dsZSBBbmFseXRpY3MgcG91ciBxdWUgY2Ugc2VydmljZSBwdWlzc2UgYW5hbHlzZXIgbGUgY29tcG9ydGVtZW50IGRlIG5hdmlnYXRpb24gZGVzIHV0aWxpc2F0ZXVycyBkdSBzaXRlLiBQb3VyIMOnYSwgR29vZ2xlIHJlY3VlaWxsZSBsZXMgaW50ZXJhY3Rpb25zIGRlcyB2aXNpdGV1cnMgYXZlYyBub3RyZSBzaXRlIHdlYiwgYWluc2kgcXVlLCBsZSBjYXMgw6ljaMOpYW50LCBsZXMgaW5mb3JtYXRpb25zIGlzc3VlcyBkZSBsYSBsZWN0dXJlIGRlcyBjb29raWVzIG91IGQnYXV0cmVzIHRlY2hub2xvZ2llcyBkZSBzdG9ja2FnZSwgcHVpcyBpbCBsZXMgdHJhaXRlIHN0YXRpc3RpcXVlbWVudCBwb3VyIG5vdXMuICAgCgpHb29nbGUgQW5hbHl0aWNzIHV0aWxpc2UgZGVzIHRlY2hub2xvZ2llcyBkZSB0cmFpdGVtZW50IGRlcyBkb25uw6llcyBxdWkgcGVybWV0dGVudCBkZSBzdWl2cmUgbGVzIHZpc2l0ZXVycyBpbmRpdmlkdWVscyBkdSBzaXRlIGV0IGxldXJzIGludGVyYWN0aW9ucyBhdmVjIGQnYXV0cmVzIHNlcnZpY2VzIEdvb2dsZSwgY29tbWUgcGFyIGV4ZW1wbGUgbGUgcsOpc2VhdSBwdWJsaWNpdGFpcmUgR29vZ2xlIEFkcy4gTGVzIGRvbm7DqWVzIHByb3ZlbmFudCBkJ2F1dHJlcyBzZXJ2aWNlcyBHb29nbGUgc29udCDDqWdhbGVtZW50IHV0aWxpc8OpZXMgcG91ciBjb21ibGVyIGxlcyBsYWN1bmVzIGRhbnMgbGVzIGRvbm7DqWVzIGV0IMOpdGFibGlyIGRlcyBzdGF0aXN0aXF1ZXMgZMOpdGFpbGzDqWVzIHN1ciBsZSBjb250ZW51IGRlIG5vdHJlIHNpdGUgd2ViLCBncsOiY2Ugw6AgZGVzIHRlY2hub2xvZ2llcyBkJ2FwcHJlbnRpc3NhZ2UgYXV0b21hdGlxdWUsIGRlcyBzdGF0aXN0aXF1ZXMgbW9kw6lsaXPDqWVzIGV0IGRlcyBmb25jdGlvbnMgZGUgcHLDqXZpc2lvbi4gCgpTaSBHb29nbGUgQW5hbHl0aWNzIGVzdCBhY3RpdsOpIHN1ciBub3RyZSBzaXRlIHdlYiwgbGVzIGRvbm7DqWVzIGNvbGxlY3TDqWVzIHBhciBHb29nbGUgQW5hbHl0aWNzIHNvbnQgdHJhbnNtaXNlcyBhdXggc2VydmV1cnMgZGUgbGEgc29jacOpdMOpIEdvb2dsZSBJcmVsYW5kIExpbWl0ZWQuIERhbnMgbGUgY2FkcmUgZHUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgcG91ciBsZSBjb21wdGUgZGUgR29vZ2xlLCBpbCBwZXV0IMOpZ2FsZW1lbnQgeSBhdm9pciB1biB0cmFuc2ZlcnQgZGUgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgdmVycyBsZXMgc2VydmV1cnMgZGUgbGEgc29jacOpdMOpIG3DqHJlIEdvb2dsZSBMTEMsIDE2MDAgQW1waGl0aGVhdHJlIFBhcmt3YXksIDk0MDQzIE1vdW50YWluIFZpZXcsIMOJdGF0cy1VbmlzLiAgIAoKT24gdXRpbGlzZSBHb29nbGUgQW5hbHl0aWNzIHBvdXIgYW5hbHlzZXIgbm90cmUgc2l0ZSB3ZWIsIGFmaW4gZGUgbCdvcHRpbWlzZXIgZW4gcGVybWFuZW5jZSBldCBkJ2VuIGFtw6lsaW9yZXIgbCdhY2Nlc3NpYmlsaXTDqS4gSWwgcydhZ2l0IGljaSBkZSBjZSBxdSdvbiBhcHBlbGxlIHVuZSBtZXN1cmUgZCdhdWRpZW5jZS4gPC9wPgo8cD5Qb3VyIGxlIHRyYWl0ZW1lbnQgbHVpLW3Dqm1lLCBsZSBzZXJ2aWNlIG91IG5vdXMtbcOqbWVzIGNvbGxlY3RvbnMgbGVzIGRvbm7DqWVzIHN1aXZhbnRlcyA6CmRlcyBkb25uw6llcyBzdXIgbGVzIGludGVyYWN0aW9ucyBkZXMgdmlzaXRldXJzIGF2ZWMgbGUgY29udGVudSBkdSBzaXRlIHdlYiwgZGVzIGRvbm7DqWVzIHN1ciBsJ3V0aWxpc2F0aW9uIGRlcyBzZXJ2aWNlcyBwcsOpc2VudMOpcyBzdXIgbm90cmUgc2l0ZSB3ZWIsIGRlcyBkb25uw6llcyBwcm92ZW5hbnQgZGUgc2VydmljZXMgR29vZ2xlIGV4dGVybmVzLCBkYW5zIGxhIG1lc3VyZSBvw7kgaWxzIGludGVyYWdpc3NlbnQgYXZlYyBub3RyZSBzaXRlIHdlYiwgY29tbWUgcGFyIGV4ZW1wbGUgbGVzIGRvbm7DqWVzIHB1YmxpY2l0YWlyZXMgb3UgY2VsbGVzIHN1ciBsZSBjb21wb3J0ZW1lbnQgdmlzLcOgLXZpcyBkZSBsYSBwdWJsaWNpdMOpLCBsZXMgZG9ubsOpZXMgc3VyIGxhIGxvY2FsaXNhdGlvbiBnw6lvZ3JhcGhpcXVlIGFwcHJveGltYXRpdmUsIGxlIG5hdmlnYXRldXIgdXRpbGlzw6ksIGxlIHN5c3TDqG1lIGQnZXhwbG9pdGF0aW9uIGFpbnNpIHF1ZSBkJ2F1dHJlcyBpbmZvcm1hdGlvbnMgc3VyIGwnYXBwYXJlaWwgdXRpbGlzw6kuPC9wPgo8cD5Hb29nbGUgQW5hbHl0aWNzIGNvbnNlcnZlcmEgbGVzIGRvbm7DqWVzIG7DqWNlc3NhaXJlcyBhdSBzdWl2aSBkdSBzaXRlIHdlYiBhdXNzaSBsb25ndGVtcHMgcXVlIG7DqWNlc3NhaXJlIHBvdXIgYXNzdXJlciBsYSBwcmVzdGF0aW9uIGR1IHNlcnZpY2UgZW4gbGlnbmUgc291c2NyaXQuIExhIGNvbGxlY3RlIGV0IGxlIHN0b2NrYWdlIGRlcyBkb25uw6llcyBzZSBmb250IGRlIG1hbmnDqHJlIGFub255bWUuIERhbnMgbGEgbWVzdXJlIG\/DuSBsZXMgaW50ZXJhY3Rpb25zIGluZGl2aWR1ZWxsZXMgZGVzIHZpc2l0ZXVycyBkdSBzaXRlIHBlcm1ldHRlbnQgZCfDqXRhYmxpciBhIHBvc3RlcmlvcmkgdW4gbGllbiBhdmVjIGRlcyBwZXJzb25uZXMgc3DDqWNpZmlxdWVzLCBvbiBzdXBwcmltZXJhIGxlcyBkb25uw6llcyBjb2xsZWN0w6llcyB1bmUgZm9pcyBsJ29iamVjdGlmIGF0dGVpbnQuIExlcyBkb25uw6llcyBzZXJvbnQgc3VwcHJpbcOpZXMgYXUgcGx1cyB0YXJkIGTDqHMgcXUnZWxsZXMgbmUgc2Vyb250IHBsdXMgc291bWlzZXMgw6AgZGVzIG9ibGlnYXRpb25zIGzDqWdhbGVzIGRlIGNvbnNlcnZhdGlvbi4gRW4gcsOoZ2xlIGfDqW7DqXJhbGUsIG9uIHN1cHByaW1lcmEgY2VzIGRvbm7DqWVzIGF1IHBsdXMgdGFyZCBhdSBib3V0IGRlIDEyIG1vaXMuICAgIAoKClR1IHBldXggY29uc3VsdGVyIGxhIGNlcnRpZmljYXRpb24gZHUgcHJlc3RhdGFpcmUgZGFucyBsZSBjYWRyZSBkdSBjYWRyZSBkZSBwcm90ZWN0aW9uIGRlcyBkb25uw6llcyBVRS3DiXRhdHMtVW5pcyDDoCBsJ2FkcmVzc2UgPGEgaHJlZj0iaHR0cHM6Ly93d3cuZGF0YXByaXZhY3lmcmFtZXdvcmsuZ292L2xpc3QiIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPmh0dHBzOi8vd3d3LmRhdGFwcml2YWN5ZnJhbWV3b3JrLmdvdi9saXN0PC9hPi48L3A+CjxwPlR1IHBldXggcmV0aXJlciB0b24gY29uc2VudGVtZW50IMOgIHRvdXQgbW9tZW50LgpUdSB0cm91dmVyYXMgcGx1cyBkJ2luZm9ybWF0aW9ucyBzdXIgbGUgcmV0cmFpdCBkZSB0b24gY29uc2VudGVtZW50IHNvaXQgZGFucyBsZSBmb3JtdWxhaXJlIGRlIGNvbnNlbnRlbWVudCBsdWktbcOqbWUsIHNvaXQgw6AgbGEgZmluIGRlIGxhIHByw6lzZW50ZSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqS48L3A+CjxwPlBvdXIgcGx1cyBkJ2luZm9ybWF0aW9ucyBzdXIgbGUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgdHJhbnNtaXNlcywgY29uc3VsdGUgbGEgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kgZHUgZm91cm5pc3NldXIgw6AgbCdhZHJlc3NlIDxhIGhyZWY9Imh0dHBzOi8vcG9saWNpZXMuZ29vZ2xlLmNvbS9wcml2YWN5IiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL3BvbGljaWVzLmdvb2dsZS5jb20vcHJpdmFjeTwvYT4uPC9wPgo8cD5MZSBmb3Vybmlzc2V1ciBwcm9wb3NlIMOpZ2FsZW1lbnQgdW5lIG9wdGlvbiBkZSBkw6lzaW5zY3JpcHRpb24gc3VyIDxhIGhyZWY9Imh0dHBzOi8vdG9vbHMuZ29vZ2xlLmNvbS9kbHBhZ2UvZ2FvcHRvdXQ\/aGw9ZGUiIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPmh0dHBzOi8vdG9vbHMuZ29vZ2xlLmNvbS9kbHBhZ2UvZ2FvcHRvdXQ\/aGw9ZGU8L2E+LjwvcD48L2xpPgo8bGk+PGgzIGlkPSJqc2VjdGlvbmFuYW1ldHJhY2tlcjEwN2Fnb29nbGVtYXBzIj48YSBuYW1lPSJ0cmFja2VyLTEwNyI+PC9hPiAgR29vZ2xlIE1hcHM8L2gzPgo8cD5TdXIgbm90cmUgc2l0ZSwgb24gdXRpbGlzZSBsZSBzZXJ2aWNlIEdvb2dsZSBNYXBzIGRlIGxhIHNvY2nDqXTDqSBHb29nbGUgSXJlbGFuZCBMaW1pdGVkLCBHb3Jkb24gSG91c2UsIEJhcnJvdyBTdHJlZXQsIDQgRHVibGluLCBJcmxhbmRlLCBlLW1haWwgOiA8YSBocmVmPSJtYWlsdG86c3VwcG9ydC1kZXV0c2NobGFuZEBnb29nbGUuY29tIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5zdXBwb3J0LWRldXRzY2hsYW5kQGdvb2dsZS5jb208L2E+LCBzaXRlIHdlYiA6IDxhIGhyZWY9Imh0dHBzOi8vd3d3Lmdvb2dsZS5jb20vIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL3d3dy5nb29nbGUuY29tLzwvYT4uCkxlcyBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCBzb250IMOpZ2FsZW1lbnQgdHJhbnNmw6lyw6llcyB2ZXJzIGxlcyDDiXRhdHMtVW5pcy4KRW4gY2UgcXVpIGNvbmNlcm5lIGxlIHRyYW5zZmVydCBkZSBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCB2ZXJzIGxlcyDDiXRhdHMtVW5pcywgaWwgZXhpc3RlIHVuZSBkw6ljaXNpb24gZCdhZMOpcXVhdGlvbiByZWxhdGl2ZSBhdSBjYWRyZSBkZSBwcm90ZWN0aW9uIGRlcyBkb25uw6llcyBVRS3DiXRhdHMtVW5pcyAoRVUtVVMgRGF0YSBQcml2YWN5IEZyYW1ld29yaykgZGUgbGEgQ29tbWlzc2lvbiBldXJvcMOpZW5uZSBhdSBzZW5zIGRlIGwnYXJ0aWNsZSA0NSBkdSBSR1BEIChjaS1hcHLDqHMgOiBEUEYgLSA8YSBocmVmPSJodHRwczovL2NvbW1pc3Npb24uZXVyb3BhLmV1L2RvY3VtZW50L2ZhMDljYmFkLWRkN2QtNDY4NC1hZTYwLWJlMDNmY2IwZmRkZl9lbiIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly9jb21taXNzaW9uLmV1cm9wYS5ldS9kb2N1bWVudC9mYTA5Y2JhZC1kZDdkLTQ2ODQtYWU2MC1iZTAzZmNiMGZkZGZfZW48L2E+ICkuCkwnZXhwbG9pdGFudCBkdSBzZXJ2aWNlIGVzdCBjZXJ0aWZpw6kgZGFucyBsZSBjYWRyZSBkdSBEUEYsIGNlIHF1aSBzaWduaWZpZSBxdWUgbGUgbml2ZWF1IGRlIHByb3RlY3Rpb24gaGFiaXR1ZWwgcHLDqXZ1IHBhciBsZSBSR1BEIHMnYXBwbGlxdWUgw6AgY2UgdHJhbnNmZXJ0LjwvcD4KPHA+TGEgYmFzZSBqdXJpZGlxdWUgZHUgdHJhaXRlbWVudCBkZSB0ZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgZXN0IHRvbiBjb25zZW50ZW1lbnQsIGNvbmZvcm3DqW1lbnQgw6AgbCdhcnRpY2xlIDYsIHBhcmFncmFwaGUgMSwgcG9pbnQgYSkgZHUgUkdQRCBvdSDDoCBsJ2FydGljbGUgOSwgcGFyYWdyYXBoZSAyLCBwb2ludCBhKSBkdSBSR1BELCBxdWUgdHUgYXMgZG9ubsOpIHN1ciBub3RyZSBzaXRlIEludGVybmV0LiAgICAgPC9wPgo8cD7DgCBub3RyZSBkZW1hbmRlLCBHb29nbGUgdXRpbGlzZXJhIGxlcyBpbmZvcm1hdGlvbnMgcmVjdWVpbGxpZXMgdmlhIEdvb2dsZSBNYXBzIHBvdXIgdCdhZmZpY2hlciBsYSBjYXJ0ZS4gR3LDomNlIMOgIEdvb2dsZSBNYXBzLCB0dSBub3VzIHRyb3V2ZXJhcyBwbHVzIHJhcGlkZW1lbnQgZXQgYXZlYyBwbHVzIGRlIHByw6ljaXNpb24gcXUnYXZlYyB1biBzaW1wbGUgcGxhbiBkJ2FjY8OocyBub24gaW50ZXJhY3RpZi4gQ2VzIGRvbm7DqWVzIHNvbnQgw6lnYWxlbWVudCB1dGlsaXPDqWVzIHBvdXIgaWRlbnRpZmllciBsZXMgdmlzaXRldXJzIGR1IHNpdGUgcXVpIGNvbnN1bHRlbnQgbm90cmUgY2FydGUgR29vZ2xlIE1hcHMsIGxlIGNhcyDDqWNow6lhbnQgw6AgbCdhaWRlIGRlIGwnaWRlbnRpZmlhbnQgcHVibGljaXRhaXJlIEdvb2dsZSwgZXQgcG91ciDDqXRhYmxpciB1biBsaWVuIGVudHJlIGNlcyB2aXNpdGVzIGV0IGxlcyB2aXNpdGVzIHBoeXNpcXVlcyBhaW5zaSBxdWUgbGVzIGNvbnN1bHRhdGlvbnMgZCdhdXRyZXMgY29vcmRvbm7DqWVzIHLDqXBlcnRvcmnDqWVzIHN1ciBHb29nbGUuIERlIGNldHRlIG1hbmnDqHJlLCBHb29nbGUgcGV1dCBlc3RpbWVyIGxlcyBmbHV4IGRlIHZpc2l0ZXVycyBhdHRlbmR1cy4gICA8L3A+CjxwPlBvdXIgbGUgdHJhaXRlbWVudCBsdWktbcOqbWUsIGxlIHNlcnZpY2Ugb3Ugbm91cy1tw6ptZXMgY29sbGVjdG9ucyBsZXMgZG9ubsOpZXMgc3VpdmFudGVzIDoKTGVzIGRvbm7DqWVzIG7DqWNlc3NhaXJlcyDDoCBsYSB2aXN1YWxpc2F0aW9uIGV0IMOgIGwnYWZmaWNoYWdlIGRlcyBkb25uw6llcyBkZSBsb2NhbGlzYXRpb24gc291cyBmb3JtZSBkZSBjYXJ0ZSwgbm90YW1tZW50IGwnYWRyZXNzZSBJUCwgbGVzIGluZm9ybWF0aW9ucyBwcm92ZW5hbnQgZGVzIHNlcnZpY2VzIGQnYXJyacOocmUtcGxhbiBkZSBHb29nbGUgdGVscyBxdWUgbGVzIEFQSSBHb29nbGUsIGxlcyB0ZXJtZXMgZGUgcmVjaGVyY2hlLCBsJ2FkcmVzc2UgSVAsIGxlcyBjb29yZG9ubsOpZXMsIGxlIHBvaW50IGRlIGTDqXBhcnQgZXQgbGEgZGVzdGluYXRpb24gZW4gY2FzIGQndXRpbGlzYXRpb24gZHUgY2FsY3VsYXRldXIgZCdpdGluw6lyYWlyZSwgbGVzIGRvbm7DqWVzIGRlIGxvY2FsaXNhdGlvbiwgbCdpZGVudGlmaWFudCBwdWJsaWNpdGFpcmUgR29vZ2xlIGV0IGwnaWRlbnRpZmlhbnQgcHVibGljaXRhaXJlIEFuZHJvaWQuPC9wPgo8cD5PbiBhIGNvbmNsdSB1biBhY2NvcmQgZGUgdHJhaXRlbWVudCBjb25qb2ludCBhdmVjIEdvb2dsZSBjb25jZXJuYW50IEdvb2dsZSBNYXBzLiBUdSBwZXV4IGNvbnN1bHRlciBsZSBjb250ZW51IGRlIGNldCBhY2NvcmQgw6AgbCdhZHJlc3NlIDxhIGhyZWY9Imh0dHBzOi8vcHJpdmFjeS5nb29nbGUuY29tL2ludGwvZGUvYnVzaW5lc3Nlcy9tYXBzY29udHJvbGxlcnRlcm1zLyIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly9wcml2YWN5Lmdvb2dsZS5jb20vaW50bC9kZS9idXNpbmVzc2VzL21hcHNjb250cm9sbGVydGVybXMvPC9hPi4gICAKClNpIGxlIHNlcnZpY2UgZXN0IGFjdGl2w6kgc3VyIG5vdHJlIHNpdGUgd2ViLCBjZWx1aS1jaSDDqXRhYmxpdCB1bmUgY29ubmV4aW9uIGF2ZWMgbGVzIHNlcnZldXJzIGRlIGxhIHNvY2nDqXTDqSBHb29nbGUgSXJlbGFuZCBMaW1pdGVkIGV0IHRyYW5zbWV0IGxlcyBkb25uw6llcyBuw6ljZXNzYWlyZXMuIERhbnMgbGUgY2FkcmUgZHUgdHJhaXRlbWVudCBkZXMgY29tbWFuZGVzLCBpbCBwZXV0IMOpZ2FsZW1lbnQgeSBhdm9pciB1biB0cmFuc2ZlcnQgZGUgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgdmVycyBsZXMgc2VydmV1cnMgZGUgbGEgc29jacOpdMOpIEdvb2dsZSBMTEMsIDE2MDAgQW1waGl0aGVhdHJlIFBhcmt3YXksIDk0MDQzIE1vdW50YWluIFZpZXcsIMOJdGF0cy1VbmlzLiAgIAoKTG9yc3F1ZSB0dSB1dGlsaXNlcyBsZSBzZXJ2aWNlIEdvb2dsZSBzdXIgbm90cmUgc2l0ZSB3ZWIsIEdvb2dsZSBwZXV0LCBsZSBjYXMgw6ljaMOpYW50LCB0cmFuc21ldHRyZSBldCB0cmFpdGVyIGRlcyBpbmZvcm1hdGlvbnMgcHJvdmVuYW50IGQnYXV0cmVzIHNlcnZpY2VzIEdvb2dsZSBhZmluIGRlIGZvdXJuaXIgZGVzIHNlcnZpY2VzIGVuIGFycmnDqHJlLXBsYW4gcG91ciBsJ2FmZmljaGFnZSBldCBsZSB0cmFpdGVtZW50IGRlcyBkb25uw6llcyBkZXMgc2VydmljZXMgcHJvcG9zw6lzIHBhciBHb29nbGUuIMOAIGNldHRlIGZpbiwgdW4gdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgcGV1dCDDqWdhbGVtZW50IMOqdHJlIGVmZmVjdHXDqSBwYXIgbGVzIHNlcnZpY2VzIEdvb2dsZSBBUEksIEdvb2dsZSBDbG91ZCBldCBHb29nbGUgRm9udHMsIGNvbmZvcm3DqW1lbnQgw6AgbGEgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kgZGUgR29vZ2xlLCBzb3VzIGxhIHJlc3BvbnNhYmlsaXTDqSBkZSBHb29nbGUgZW4gbWF0acOocmUgZGUgcHJvdGVjdGlvbiBkZXMgZG9ubsOpZXMuIAoKClR1IHBldXggY29uc3VsdGVyIGxhIGNlcnRpZmljYXRpb24gZHUgcHJlc3RhdGFpcmUgZGFucyBsZSBjYWRyZSBkdSBjYWRyZSBkZSBwcm90ZWN0aW9uIGRlcyBkb25uw6llcyBVRS3DiXRhdHMtVW5pcyDDoCBsJ2FkcmVzc2UgPGEgaHJlZj0iaHR0cHM6Ly93d3cuZGF0YXByaXZhY3lmcmFtZXdvcmsuZ292L2xpc3QiIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPmh0dHBzOi8vd3d3LmRhdGFwcml2YWN5ZnJhbWV3b3JrLmdvdi9saXN0PC9hPi48L3A+CjxwPlR1IHBldXggcmV0aXJlciB0b24gY29uc2VudGVtZW50IMOgIHRvdXQgbW9tZW50LgpUdSB0cm91dmVyYXMgcGx1cyBkJ2luZm9ybWF0aW9ucyBzdXIgbGUgcmV0cmFpdCBkZSB0b24gY29uc2VudGVtZW50IHNvaXQgZGFucyBsZSBmb3JtdWxhaXJlIGRlIGNvbnNlbnRlbWVudCBsdWktbcOqbWUsIHNvaXQgw6AgbGEgZmluIGRlIGxhIHByw6lzZW50ZSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqS48L3A+CjxwPlBvdXIgcGx1cyBkJ2luZm9ybWF0aW9ucyBzdXIgbGUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgdHJhbnNtaXNlcywgY29uc3VsdGUgbGEgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kgZHUgZm91cm5pc3NldXIgw6AgbCdhZHJlc3NlIDxhIGhyZWY9Imh0dHBzOi8vcG9saWNpZXMuZ29vZ2xlLmNvbS9wcml2YWN5IiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL3BvbGljaWVzLmdvb2dsZS5jb20vcHJpdmFjeTwvYT4uPC9wPgo8cD5MZSBmb3Vybmlzc2V1ciBwcm9wb3NlIMOpZ2FsZW1lbnQgdW5lIG9wdGlvbiBkZSBkw6lzaW5zY3JpcHRpb24gc3VyIDxhIGhyZWY9Imh0dHBzOi8vc3VwcG9ydC5nb29nbGUuY29tL015LUFkLUNlbnRlci1IZWxwL2Fuc3dlci8xMjE1NTQ1MT9obD1kZSIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly9zdXBwb3J0Lmdvb2dsZS5jb20vTXktQWQtQ2VudGVyLUhlbHAvYW5zd2VyLzEyMTU1NDUxP2hsPWRlPC9hPi48L3A+PC9saT4KPGxpPjxoMyBpZD0ianNlY3Rpb25hbmFtZXRyYWNrZXIxMTJhZ29vZ2xldGFnbWFuYWdlciI+PGEgbmFtZT0idHJhY2tlci0xMTIiPjwvYT4gIEdvb2dsZSBUYWcgTWFuYWdlcjwvaDM+CjxwPlN1ciBub3RyZSBzaXRlLCBvbiB1dGlsaXNlIGxlIHNlcnZpY2UgR29vZ2xlIFRhZyBNYW5hZ2VyIGRlIGxhIHNvY2nDqXTDqSBHb29nbGUgSXJlbGFuZCBMdGQuLCBHb3Jkb24gSG91c2UsIEJhcnJvdyBTdHJlZXQsIDQgRHVibGluLCBJcmxhbmRlLCBlLW1haWwgOiA8YSBocmVmPSJtYWlsdG86c3VwcG9ydC1kZXV0c2NobGFuZEBnb29nbGUuY29tIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5zdXBwb3J0LWRldXRzY2hsYW5kQGdvb2dsZS5jb208L2E+LCBzaXRlIHdlYiA6IDxhIGhyZWY9Imh0dHBzOi8vd3d3Lmdvb2dsZS5jb20vIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL3d3dy5nb29nbGUuY29tLzwvYT4uCkxlcyBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCBzb250IMOpZ2FsZW1lbnQgdHJhbnNmw6lyw6llcyB2ZXJzIGxlcyDDiXRhdHMtVW5pcy4KRW4gY2UgcXVpIGNvbmNlcm5lIGxlIHRyYW5zZmVydCBkZSBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCB2ZXJzIGxlcyDDiXRhdHMtVW5pcywgaWwgZXhpc3RlIHVuZSBkw6ljaXNpb24gZCdhZMOpcXVhdGlvbiByZWxhdGl2ZSBhdSBjYWRyZSBkZSBwcm90ZWN0aW9uIGRlcyBkb25uw6llcyBVRS3DiXRhdHMtVW5pcyAoRVUtVVMgRGF0YSBQcml2YWN5IEZyYW1ld29yaykgZGUgbGEgQ29tbWlzc2lvbiBldXJvcMOpZW5uZSBhdSBzZW5zIGRlIGwnYXJ0aWNsZSA0NSBkdSBSR1BEIChjaS1hcHLDqHMgOiBEUEYgLSA8YSBocmVmPSJodHRwczovL2NvbW1pc3Npb24uZXVyb3BhLmV1L2RvY3VtZW50L2ZhMDljYmFkLWRkN2QtNDY4NC1hZTYwLWJlMDNmY2IwZmRkZl9lbiIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly9jb21taXNzaW9uLmV1cm9wYS5ldS9kb2N1bWVudC9mYTA5Y2JhZC1kZDdkLTQ2ODQtYWU2MC1iZTAzZmNiMGZkZGZfZW48L2E+ICkuCkwnZXhwbG9pdGFudCBkdSBzZXJ2aWNlIGVzdCBjZXJ0aWZpw6kgZGFucyBsZSBjYWRyZSBkdSBEUEYsIGNlIHF1aSBzaWduaWZpZSBxdWUgbGUgbml2ZWF1IGRlIHByb3RlY3Rpb24gaGFiaXR1ZWwgZHUgUkdQRCBzJ2FwcGxpcXVlIMOgIGNlIHRyYW5zZmVydC48L3A+CjxwPkxhIGJhc2UganVyaWRpcXVlIGR1IHRyYWl0ZW1lbnQgZGUgdGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIGVzdCB0b24gY29uc2VudGVtZW50LCBjb25mb3Jtw6ltZW50IMOgIGwnYXJ0aWNsZSA2LCBwYXJhZ3JhcGhlIDEsIHBvaW50IGEpIGR1IFJHUEQgb3Ugw6AgbCdhcnRpY2xlIDksIHBhcmFncmFwaGUgMiwgcG9pbnQgYSkgZHUgUkdQRCwgcXVlIHR1IGFzIGRvbm7DqSBzdXIgbm90cmUgc2l0ZSBJbnRlcm5ldC4gICAgIDwvcD4KPHA+R29vZ2xlIFRhZyBNYW5hZ2VyIG9mZnJlIHVuZSBwbGF0ZWZvcm1lIHRlY2huaXF1ZSBwZXJtZXR0YW50IGQnZXjDqWN1dGVyIGQnYXV0cmVzIG91dGlscyB3ZWIgZXQgcHJvZ3JhbW1lcyBkZSBzdWl2aSB3ZWIgw6AgbCdhaWRlIGRlIMKrIGJhbGlzZXMgwrsgZXQgZGUgbGVzIGfDqXJlciBkZSBtYW5pw6hyZSBjZW50cmFsaXPDqWUuICAKCkRhbnMgY2UgY29udGV4dGUsIEdvb2dsZSBUYWcgTWFuYWdlciBlbnJlZ2lzdHJlIGRlcyBjb29raWVzIHN1ciB0b24gb3JkaW5hdGV1ciBldCwgZGFucyBsYSBtZXN1cmUgb8O5IGRlcyBvdXRpbHMgZGUgc3Vpdmkgd2ViIHNvbnQgdXRpbGlzw6lzIHZpYSBHb29nbGUgVGFnIE1hbmFnZXIsIGFuYWx5c2UgdG9uIGNvbXBvcnRlbWVudCBkZSBuYXZpZ2F0aW9uIChjZSBxdSdvbiBhcHBlbGxlIGxlIMKrIHN1aXZpIMK7KS4gTGVzIGRvbm7DqWVzIGfDqW7DqXLDqWVzIHBhciBsZXMgwqsgYmFsaXNlcyDCuyBzb250IHJlZ3JvdXDDqWVzLCBzdG9ja8OpZXMgZXQgdHJhaXTDqWVzIHBhciBHb29nbGUgVGFnIE1hbmFnZXIgYXUgc2VpbiBkJ3VuZSBpbnRlcmZhY2UgdXRpbGlzYXRldXIgdW5pcXVlLiAKClRvdXMgbGVzIMKrIHRhZ3MgwrsgaW50w6lncsOpcyBzb250IMOgIG5vdXZlYXUgcsOpcGVydG9yacOpcyBzw6lwYXLDqW1lbnQgZGFucyBsYSBwcsOpc2VudGUgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kuIExvcnNxdWUgdHUgdXRpbGlzZXMgbm90cmUgc2l0ZSB3ZWIgZXQgcXVlIGwnaW50w6lncmF0aW9uIGRlcyDCqyB0YWdzIMK7IGRlIEdvb2dsZSBUYWcgTWFuYWdlciBlc3QgYWN0aXbDqWUsIGRlcyBkb25uw6llcywgbm90YW1tZW50IHRvbiBhZHJlc3NlIElQIGV0IHRlcyBhY3Rpdml0w6lzIGQndXRpbGlzYXRldXIsIHNvbnQgdHJhbnNtaXNlcyBhdXggc2VydmV1cnMgZGUgbGEgc29jacOpdMOpIEdvb2dsZS4gTGVzIG91dGlscyBkZSBzdWl2aSB1dGlsaXPDqXMgZGFucyBHb29nbGUgVGFnIE1hbmFnZXIgZ2FyYW50aXNzZW50LCBncsOiY2Ugw6AgdW5lIGFub255bWlzYXRpb24gZGUgbCdhZHJlc3NlIElQIGRhbnMgbGUgY29kZSBzb3VyY2UsIHF1ZSBsJ2FkcmVzc2UgSVAgZXN0IGFub255bWlzw6llIHBhciBHb29nbGUgVGFnIE1hbmFnZXIgYXZhbnQgZCfDqnRyZSB0cmFuc21pc2UuIEF2ZWMgR29vZ2xlIFRhZyBNYW5hZ2VyLCBvbiBwZXV0LCBncsOiY2Ugw6AgY2UgcXXigJlvbiBhcHBlbGxlIGxhIGdlc3Rpb24gZGVzIGJhbGlzZXMsIHJlbGllciBlbnRyZSBlbGxlcyBldCBhbmFseXNlciBsZXMgZG9ubsOpZXMgZGUgbWVzdXJlIGRlIGRpZmbDqXJlbnRzIHByZXN0YXRhaXJlcyAoR29vZ2xlIGV0IGRlcyB0aWVycykuIEdvb2dsZSBUYWcgTWFuYWdlciBub3VzIGFpZGUgw6Agw6l0YWJsaXIgZGVzIHJhcHBvcnRzIHN1ciBsZXMgYWN0aXZpdMOpcyBkdSBzaXRlIHdlYiBldCDDoCBnw6lyZXIgbGVzIG91dGlscyB3ZWIgZGUgbm90cmUgc2l0ZS4gICAgPC9wPgo8cD5Qb3VyIGxlIHRyYWl0ZW1lbnQgbHVpLW3Dqm1lLCBsZSBzZXJ2aWNlIG91IG5vdXMtbcOqbWVzIGNvbGxlY3RvbnMgbGVzIGRvbm7DqWVzIHN1aXZhbnRlcyA6CmNvb2tpZXMsIGRvbm7DqWVzIGRlIHN1aXZpIHdlYiwgbGllbnMgc29ydGFudHMgb3UgZW50cmFudHMsIGluZm9ybWF0aW9ucyBnw6luw6lyw6llcyBsb3JzIGRlIGwnaW50w6lncmF0aW9uIGV0IGRlIGwnYWN0aXZhdGlvbiBkdSBjb2RlIEphdmFTY3JpcHQgc3VyIGxlIHNpdGUgd2ViIHBhciBHb29nbGUgVGFnIE1hbmFnZXIgZXQgbGVzIG91dGlscyB3ZWIgZMOpY2xlbmNow6lzIHBhciBHb29nbGUgVGFnIE1hbmFnZXIuPC9wPgo8cD4KVHUgcGV1eCBjb25zdWx0ZXIgbGEgY2VydGlmaWNhdGlvbiBkdSBwcmVzdGF0YWlyZSBkYW5zIGxlIGNhZHJlIGR1IGNhZHJlIGRlIHByb3RlY3Rpb24gZGVzIGRvbm7DqWVzIFVFLcOJdGF0cy1VbmlzIMOgIGwnYWRyZXNzZSA8YSBocmVmPSJodHRwczovL3d3dy5kYXRhcHJpdmFjeWZyYW1ld29yay5nb3YvbGlzdCIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly93d3cuZGF0YXByaXZhY3lmcmFtZXdvcmsuZ292L2xpc3Q8L2E+LjwvcD4KPHA+VHUgcGV1eCByZXRpcmVyIHRvbiBjb25zZW50ZW1lbnQgw6AgdG91dCBtb21lbnQuClR1IHRyb3V2ZXJhcyBwbHVzIGQnaW5mb3JtYXRpb25zIHN1ciBsZSByZXRyYWl0IGRlIHRvbiBjb25zZW50ZW1lbnQgc29pdCBkYW5zIGxlIGZvcm11bGFpcmUgZGUgY29uc2VudGVtZW50IGx1aS1tw6ptZSwgc29pdCDDoCBsYSBmaW4gZGUgbGEgcHLDqXNlbnRlIHBvbGl0aXF1ZSBkZSBjb25maWRlbnRpYWxpdMOpLjwvcD4KPHA+UG91ciBwbHVzIGQnaW5mb3JtYXRpb25zIHN1ciBsZSB0cmFpdGVtZW50IGRlcyBkb25uw6llcyB0cmFuc21pc2VzLCBjb25zdWx0ZSBsYSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqSBkdSBmb3Vybmlzc2V1ciDDoCBsJ2FkcmVzc2UgPGEgaHJlZj0iaHR0cHM6Ly9wb2xpY2llcy5nb29nbGUuY29tL3ByaXZhY3kiIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPmh0dHBzOi8vcG9saWNpZXMuZ29vZ2xlLmNvbS9wcml2YWN5PC9hPi48L3A+CjxwPkxlIGZvdXJuaXNzZXVyIHByb3Bvc2Ugw6lnYWxlbWVudCB1bmUgb3B0aW9uIGRlIGTDqXNpbnNjcmlwdGlvbiBzdXIgPGEgaHJlZj0iaHR0cHM6Ly9wb2xpY2llcy5nb29nbGUuY29tL3ByaXZhY3kiIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPmh0dHBzOi8vcG9saWNpZXMuZ29vZ2xlLmNvbS9wcml2YWN5PC9hPi48L3A+PC9saT4KPGxpPjxoMyBpZD0ianNlY3Rpb25hbmFtZXRyYWNrZXIxMTZhZ3N0YXRpYyI+PGEgbmFtZT0idHJhY2tlci0xMTYiPjwvYT4gIEdzdGF0aWM8L2gzPgo8cD5TdXIgbm90cmUgc2l0ZSwgb24gdXRpbGlzZSBsZSBzZXJ2aWNlIEdzdGF0aWMgZGUgbGEgc29jacOpdMOpIEdvb2dsZSBJcmVsYW5kIExpbWl0ZWQsIEdvcmRvbiBIb3VzZSwgQmFycm93IFN0cmVldCwgNCBEdWJsaW4sIElybGFuZGUsIGUtbWFpbCA6IDxhIGhyZWY9Im1haWx0bzpzdXBwb3J0LWRldXRzY2hsYW5kQGdvb2dsZS5jb20iIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPnN1cHBvcnQtZGV1dHNjaGxhbmRAZ29vZ2xlLmNvbTwvYT4sIHNpdGUgd2ViIDogPGEgaHJlZj0iaHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS8iIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPmh0dHBzOi8vd3d3Lmdvb2dsZS5jb20vPC9hPi4KTGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIHNvbnQgw6lnYWxlbWVudCB0cmFuc2bDqXLDqWVzIHZlcnMgbGVzIMOJdGF0cy1VbmlzLgpFbiBjZSBxdWkgY29uY2VybmUgbGUgdHJhbnNmZXJ0IGRlIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIHZlcnMgbGVzIMOJdGF0cy1VbmlzLCBpbCBleGlzdGUgdW5lIGTDqWNpc2lvbiBkJ2Fkw6lxdWF0aW9uIHJlbGF0aXZlIGF1IGNhZHJlIGRlIHByb3RlY3Rpb24gZGVzIGRvbm7DqWVzIFVFLcOJdGF0cy1VbmlzIChFVS1VUyBEYXRhIFByaXZhY3kgRnJhbWV3b3JrKSBkZSBsYSBDb21taXNzaW9uIGV1cm9ww6llbm5lLCBhdSBzZW5zIGRlIGwnYXJ0aWNsZSA0NSBkdSBSR1BEIChjaS1hcHLDqHMgOiBEUEYgLSA8YSBocmVmPSJodHRwczovL2NvbW1pc3Npb24uZXVyb3BhLmV1L2RvY3VtZW50L2ZhMDljYmFkLWRkN2QtNDY4NC1hZTYwLWJlMDNmY2IwZmRkZl9lbiIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly9jb21taXNzaW9uLmV1cm9wYS5ldS9kb2N1bWVudC9mYTA5Y2JhZC1kZDdkLTQ2ODQtYWU2MC1iZTAzZmNiMGZkZGZfZW48L2E+ICkuCkwnZXhwbG9pdGFudCBkdSBzZXJ2aWNlIGVzdCBjZXJ0aWZpw6kgZGFucyBsZSBjYWRyZSBkdSBEUEYsIGNlIHF1aSBzaWduaWZpZSBxdWUgbGUgbml2ZWF1IGRlIHByb3RlY3Rpb24gaGFiaXR1ZWwgcHLDqXZ1IHBhciBsZSBSR1BEIHMnYXBwbGlxdWUgw6AgY2UgdHJhbnNmZXJ0LjwvcD4KPHA+TGEgYmFzZSBqdXJpZGlxdWUgZHUgdHJhaXRlbWVudCBkZSB0ZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgZXN0IHRvbiBjb25zZW50ZW1lbnQsIGNvbmZvcm3DqW1lbnQgw6AgbCdhcnRpY2xlIDYsIHBhcmFncmFwaGUgMSwgcG9pbnQgYSkgZHUgUkdQRCBvdSDDoCBsJ2FydGljbGUgOSwgcGFyYWdyYXBoZSAyLCBwb2ludCBhKSBkdSBSR1BELCBxdWUgdHUgYXMgZG9ubsOpIHN1ciBub3RyZSBzaXRlIEludGVybmV0LiAgICAgPC9wPgo8cD5Hc3RhdGljIGVzdCB1biBzZXJ2aWNlIGVuIGFycmnDqHJlLXBsYW4gdXRpbGlzw6kgcGFyIEdvb2dsZSBwb3VyIHLDqWN1cMOpcmVyIGR1IGNvbnRlbnUgc3RhdGlxdWUsIGRhbnMgbGUgYnV0IGRlIHLDqWR1aXJlIGwndXRpbGlzYXRpb24gZGUgbGEgYmFuZGUgcGFzc2FudGUgZXQgZGUgY2hhcmdlciDDoCBsJ2F2YW5jZSBsZXMgZmljaGllcnMgZGUgY2F0YWxvZ3VlIG7DqWNlc3NhaXJlcy4gQ2Ugc2VydmljZSBjaGFyZ2Ugbm90YW1tZW50IGRlcyBkb25uw6llcyBlbiBhcnJpw6hyZS1wbGFuIHBvdXIgR29vZ2xlIEZvbnRzIGV0IEdvb2dsZSBNYXBzLiA8L3A+CjxwPkRhbnMgbGUgY2FkcmUgZHUgdHJhaXRlbWVudCBkZXMgY29tbWFuZGVzLCBkZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgcGV1dmVudCDDqWdhbGVtZW50IMOqdHJlIHRyYW5zZsOpcsOpZXMgdmVycyBsZXMgc2VydmV1cnMgZGUgbGEgc29jacOpdMOpIEdvb2dsZSBMTEMsIDE2MDAgQW1waGl0aGVhdHJlIFBhcmt3YXksIDk0MDQzIE1vdW50YWluIFZpZXcsIMOJdGF0cy1VbmlzLgoKVHUgcGV1eCBjb25zdWx0ZXIgbGEgY2VydGlmaWNhdGlvbiBkdSBwcmVzdGF0YWlyZSBkYW5zIGxlIGNhZHJlIGR1IGNhZHJlIGRlIHByb3RlY3Rpb24gZGVzIGRvbm7DqWVzIFVFLcOJdGF0cy1VbmlzIMOgIGwnYWRyZXNzZSA8YSBocmVmPSJodHRwczovL3d3dy5kYXRhcHJpdmFjeWZyYW1ld29yay5nb3YvbGlzdCIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly93d3cuZGF0YXByaXZhY3lmcmFtZXdvcmsuZ292L2xpc3Q8L2E+LjwvcD4KPHA+VHUgcGV1eCByZXRpcmVyIHRvbiBjb25zZW50ZW1lbnQgw6AgdG91dCBtb21lbnQuClR1IHRyb3V2ZXJhcyBwbHVzIGQnaW5mb3JtYXRpb25zIHN1ciBsZSByZXRyYWl0IGRlIHRvbiBjb25zZW50ZW1lbnQgc29pdCBkYW5zIGxlIGZvcm11bGFpcmUgZGUgY29uc2VudGVtZW50IGx1aS1tw6ptZSwgc29pdCDDoCBsYSBmaW4gZGUgbGEgcHLDqXNlbnRlIHBvbGl0aXF1ZSBkZSBjb25maWRlbnRpYWxpdMOpLjwvcD4KPHA+UG91ciBwbHVzIGQnaW5mb3JtYXRpb25zIHN1ciBsZSB0cmFpdGVtZW50IGRlcyBkb25uw6llcyB0cmFuc21pc2VzLCBjb25zdWx0ZSBsYSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqSBkdSBmb3Vybmlzc2V1ciDDoCBsJ2FkcmVzc2UgPGEgaHJlZj0iaHR0cHM6Ly9wb2xpY2llcy5nb29nbGUuY29tL3ByaXZhY3kiIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPmh0dHBzOi8vcG9saWNpZXMuZ29vZ2xlLmNvbS9wcml2YWN5PC9hPi48L3A+CjxwPkxlIGZvdXJuaXNzZXVyIHByb3Bvc2Ugw6lnYWxlbWVudCB1bmUgb3B0aW9uIGRlIGTDqXNpbnNjcmlwdGlvbiBzdXIgPGEgaHJlZj0iaHR0cHM6Ly9zdXBwb3J0Lmdvb2dsZS5jb20vTXktQWQtQ2VudGVyLUhlbHAvYW5zd2VyLzEyMTU1NDUxP2hsPWRlIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL3N1cHBvcnQuZ29vZ2xlLmNvbS9NeS1BZC1DZW50ZXItSGVscC9hbnN3ZXIvMTIxNTU0NTE\/aGw9ZGU8L2E+LjwvcD48L2xpPgo8L3VsPgo8aDIgaWQ9ImpzZWN0aW9uZWluYmluZHVuZ2V4dGVybmVyd2Vic2VydmljZXN1bmR2ZXJhcmJlaXR1bmd2b25kYXRlbmF1ZXJoYWxiZGVyZXUiPkludMOpZ3JhdGlvbiBkZSBzZXJ2aWNlcyB3ZWIgZXh0ZXJuZXMgZXQgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgZW4gZGVob3JzIGRlIGwnVUU8L2gyPgo8cD5TdXIgbm90cmUgc2l0ZSBJbnRlcm5ldCwgb24gdXRpbGlzZSBkZXMgY29udGVudXMgYWN0aWZzIHByb3ZlbmFudCBkZSBmb3Vybmlzc2V1cnMgZXh0ZXJuZXMsIGNlIHF1J29uIGFwcGVsbGUgZGVzIMKrIHNlcnZpY2VzIFdlYiDCuy4KTG9yc3F1ZSB0dSBjb25zdWx0ZXMgbm90cmUgc2l0ZSBJbnRlcm5ldCwgY2VzIGZvdXJuaXNzZXVycyBleHRlcm5lcyBwZXV2ZW50LCBsZSBjYXMgw6ljaMOpYW50LCBvYnRlbmlyIGRlcyBpbmZvcm1hdGlvbnMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgY29uY2VybmFudCB0YSB2aXNpdGUgc3VyIG5vdHJlIHNpdGUuCkRhbnMgY2UgY2FkcmUsIHVuIHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzIGVuIGRlaG9ycyBkZSBsJ1VFIGVzdCBwb3NzaWJsZS4KVHUgcGV1eCBlbXDDqmNoZXIgY2VsYSBlbiBpbnN0YWxsYW50IHVuIHBsdWdpbiBkZSBuYXZpZ2F0ZXVyIGFkYXB0w6kgb3UgZW4gZMOpc2FjdGl2YW50IGwnZXjDqWN1dGlvbiBkZXMgc2NyaXB0cyBkYW5zIHRvbiBuYXZpZ2F0ZXVyLgpDZWxhIHBldXQgZW50cmHDrm5lciBkZXMgcmVzdHJpY3Rpb25zIGRlIGZvbmN0aW9ubmFsaXTDqSBzdXIgbGVzIHNpdGVzIHdlYiBxdWUgdHUgdmlzaXRlcy48L3A+CjxwPk9uIHV0aWxpc2UgbGVzIHNlcnZpY2VzIHdlYiBleHRlcm5lcyBzdWl2YW50cyA6PC9wPgo8dWw+CjxsaT48aDMgaWQ9ImpzZWN0aW9uYW5hbWV0cmFja2VyMTIxNmFmb250YXdlc29tZSI+PGEgbmFtZT0idHJhY2tlci0xMjE2Ij48L2E+ICBGb250IEF3ZXNvbWU8L2gzPgo8cD5TdXIgbm90cmUgc2l0ZSwgb24gdXRpbGlzZSBsZSBzZXJ2aWNlIEZvbnQgQXdlc29tZSBkZSBsYSBzb2Npw6l0w6kgRm9udGljb25zIEluYy4sIDYgUG9ydGVyIFJvYWQsIEFwcGFydGVtZW50IDNSLCBNQSAwMjE0MCBDYW1icmlkZ2UsIMOJdGF0cy1VbmlzLCBlLW1haWwgOiA8YSBocmVmPSJtYWlsdG86aGVsbG9AZm9udGF3ZXNvbWUuY29tIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5oZWxsb0Bmb250YXdlc29tZS5jb208L2E+LCBzaXRlIHdlYiA6IDxhIGhyZWY9Imh0dHBzOi8vZm9udGF3ZXNvbWUuY29tLyIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly9mb250YXdlc29tZS5jb20vPC9hPi4KTGUgdHJhbnNmZXJ0IHMnZWZmZWN0dWUgw6lnYWxlbWVudCB2ZXJzIHVuIHBheXMgdGllcnMgcG91ciBsZXF1ZWwgaWwgbidleGlzdGUgcGFzIGRlIGTDqWNpc2lvbiBkJ2Fkw6lxdWF0aW9uIGRlIGxhIENvbW1pc3Npb24uClBhciBjb25zw6lxdWVudCwgbGUgbml2ZWF1IGRlIHByb3RlY3Rpb24gaGFiaXR1ZWwgcHLDqXZ1IHBhciBsZSBSR1BEIG5lIHBldXQgw6p0cmUgZ2FyYW50aSBsb3JzIGR1IHRyYW5zZmVydCwgY2FyIG9uIG5lIHBldXQgZXhjbHVyZSBxdWUsIGRhbnMgY2UgcGF5cyB0aWVycywgbGVzIGF1dG9yaXTDqXMsIHBhciBleGVtcGxlLCBwdWlzc2VudCBhdm9pciBhY2PDqHMgYXV4IGRvbm7DqWVzIGNvbGxlY3TDqWVzLjwvcD4KPHA+TGEgYmFzZSBqdXJpZGlxdWUgZHUgdHJhaXRlbWVudCBkZSB0ZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgZXN0IHRvbiBjb25zZW50ZW1lbnQsIGNvbmZvcm3DqW1lbnQgw6AgbCdhcnRpY2xlIDYsIHBhcmFncmFwaGUgMSwgcG9pbnQgYSkgZHUgUkdQRCBvdSDDoCBsJ2FydGljbGUgOSwgcGFyYWdyYXBoZSAyLCBwb2ludCBhKSBkdSBSR1BELCBxdWUgdHUgYXMgZG9ubsOpIHN1ciBub3RyZSBzaXRlIEludGVybmV0LiAgICAgPC9wPgo8cD5HcsOiY2UgYXUgc2VydmljZSBGb250IEF3ZXNvbWUsIGRlcyBwb2xpY2VzIHNvbnQgY2hhcmfDqWVzIHN1ciBub3RyZSBzaXRlIGFmaW4gZGUgdGUgcHJvcG9zZXIgdW5lIHZlcnNpb24gcGx1cyBhZ3LDqWFibGUgw6AgcmVnYXJkZXIuPC9wPgo8cD5UdSBwZXV4IHJldGlyZXIgdG9uIGNvbnNlbnRlbWVudCDDoCB0b3V0IG1vbWVudC4KVHUgdHJvdXZlcmFzIHBsdXMgZCdpbmZvcm1hdGlvbnMgc3VyIGxlIHJldHJhaXQgZGUgdG9uIGNvbnNlbnRlbWVudCBzb2l0IGRhbnMgbGUgZm9ybXVsYWlyZSBkZSBjb25zZW50ZW1lbnQgbHVpLW3Dqm1lLCBzb2l0IMOgIGxhIGZpbiBkZSBjZXR0ZSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqS48L3A+CjxwPlBvdXIgcGx1cyBkJ2luZm9ybWF0aW9ucyBzdXIgbGUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgdHJhbnNtaXNlcywgY29uc3VsdGUgbGEgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kgZHUgZm91cm5pc3NldXIgw6AgbCdhZHJlc3NlIDxhIGhyZWY9Imh0dHBzOi8vZm9udGF3ZXNvbWUuY29tL3ByaXZhY3kiIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPmh0dHBzOi8vZm9udGF3ZXNvbWUuY29tL3ByaXZhY3k8L2E+LjwvcD48L2xpPgoKCjxsaT48aDMgaWQ9ImpzZWN0aW9uYW5hbWV0cmFja2VyMTExYWdvb2dsZWNsb3VkYXBpcyI+PGEgbmFtZT0idHJhY2tlci0xMTEiPjwvYT4gIEFQSSBHb29nbGUgQ2xvdWQ8L2gzPgo8cD5TdXIgbm90cmUgc2l0ZSwgb24gdXRpbGlzZSBsZSBzZXJ2aWNlIEdvb2dsZSBDbG91ZCBBUElzIGRlIGxhIHNvY2nDqXTDqSBHb29nbGUgSXJlbGFuZCBMaW1pdGVkLCBHb3Jkb24gSG91c2UsIEJhcnJvdyBTdHJlZXQsIDQgRHVibGluLCBJcmxhbmRlLCBlLW1haWwgOiA8YSBocmVmPSJtYWlsdG86c3VwcG9ydC1kZXV0c2NobGFuZEBnb29nbGUuY29tIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5zdXBwb3J0LWRldXRzY2hsYW5kQGdvb2dsZS5jb208L2E+LCBzaXRlIHdlYiA6IDxhIGhyZWY9Imh0dHBzOi8vd3d3Lmdvb2dsZS5jb20vIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL3d3dy5nb29nbGUuY29tLzwvYT4uCkxlcyBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCBzb250IMOpZ2FsZW1lbnQgdHJhbnNmw6lyw6llcyB2ZXJzIGxlcyDDiXRhdHMtVW5pcy4KRW4gY2UgcXVpIGNvbmNlcm5lIGxlIHRyYW5zZmVydCBkZSBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCB2ZXJzIGxlcyDDiXRhdHMtVW5pcywgaWwgZXhpc3RlIHVuZSBkw6ljaXNpb24gZCdhZMOpcXVhdGlvbiByZWxhdGl2ZSBhdSBjYWRyZSBkZSBwcm90ZWN0aW9uIGRlcyBkb25uw6llcyBVRS3DiXRhdHMtVW5pcyAoRVUtVVMgRGF0YSBQcml2YWN5IEZyYW1ld29yaykgZGUgbGEgQ29tbWlzc2lvbiBldXJvcMOpZW5uZSBhdSBzZW5zIGRlIGwnYXJ0aWNsZSA0NSBkdSBSR1BEIChjaS1hcHLDqHMgOiBEUEYgLSA8YSBocmVmPSJodHRwczovL2NvbW1pc3Npb24uZXVyb3BhLmV1L2RvY3VtZW50L2ZhMDljYmFkLWRkN2QtNDY4NC1hZTYwLWJlMDNmY2IwZmRkZl9lbiIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly9jb21taXNzaW9uLmV1cm9wYS5ldS9kb2N1bWVudC9mYTA5Y2JhZC1kZDdkLTQ2ODQtYWU2MC1iZTAzZmNiMGZkZGZfZW48L2E+ICkuCkwnZXhwbG9pdGFudCBkdSBzZXJ2aWNlIGVzdCBjZXJ0aWZpw6kgZGFucyBsZSBjYWRyZSBkdSBEUEYsIGNlIHF1aSBzaWduaWZpZSBxdWUgbGUgbml2ZWF1IGRlIHByb3RlY3Rpb24gaGFiaXR1ZWwgZHUgUkdQRCBzJ2FwcGxpcXVlIMOgIGNlIHRyYW5zZmVydC48L3A+CjxwPkxhIGJhc2UganVyaWRpcXVlIGR1IHRyYWl0ZW1lbnQgZGUgdGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIGVzdCB0b24gY29uc2VudGVtZW50LCBjb25mb3Jtw6ltZW50IMOgIGwnYXJ0aWNsZSA2LCBwYXJhZ3JhcGhlIDEsIHBvaW50IGEpLCBkdSBSR1BEIG91IMOgIGwnYXJ0aWNsZSA5LCBwYXJhZ3JhcGhlIDIsIHBvaW50IGEpLCBkdSBSR1BELCBxdWUgdHUgYXMgZG9ubsOpIHN1ciBub3RyZSBzaXRlIEludGVybmV0LiAgICAgPC9wPgo8cD5PbiB1dGlsaXNlIGxlcyBBUEkgR29vZ2xlIHBvdXIgcG91dm9pciBjaGFyZ2VyIGQnYXV0cmVzIHNlcnZpY2VzIEdvb2dsZSBzdXIgbGUgc2l0ZSB3ZWIuIExlcyBBUEkgR29vZ2xlLCBjJ2VzdCB1biBlbnNlbWJsZSBkJ2ludGVyZmFjZXMgcXVpIHBlcm1ldHRlbnQgbGEgY29tbXVuaWNhdGlvbiBlbnRyZSBsZXMgZGlmZsOpcmVudHMgc2VydmljZXMgR29vZ2xlIHV0aWxpc8OpcyBzdXIgdG9uIHNpdGUgd2ViLiBDZSBzZXJ2aWNlIHNlcnQgbm90YW1tZW50IMOgIGFmZmljaGVyIGxlcyBwb2xpY2VzIEdvb2dsZSBGb250cyBldCDDoCBtZXR0cmUgw6AgZGlzcG9zaXRpb24gbGEgY2FydGUgR29vZ2xlIE1hcHMuICA8L3A+CjxwPlBvdXIgbGUgdHJhaXRlbWVudCBsdWktbcOqbWUsIGxlIHNlcnZpY2Ugb3Ugbm91cy1tw6ptZXMgY29sbGVjdG9ucyBsZXMgZG9ubsOpZXMgc3VpdmFudGVzIDoKYWRyZXNzZSBJUDwvcD4KPHA+U2kgbGUgc2VydmljZSBlc3QgYWN0aXbDqSBzdXIgbm90cmUgc2l0ZSB3ZWIsIGNlbHVpLWNpIMOpdGFibGl0IHVuZSBjb25uZXhpb24gYXZlYyBsZXMgc2VydmV1cnMgZGUgbGEgc29jacOpdMOpIEdvb2dsZSBJcmVsYW5kIExpbWl0ZWQgZXQgdHJhbnNtZXQgbGVzIGRvbm7DqWVzIG7DqWNlc3NhaXJlcy4gRGFucyBsZSBjYWRyZSBkdSB0cmFpdGVtZW50IGRlcyBjb21tYW5kZXMsIGlsIHBldXQgw6lnYWxlbWVudCB5IGF2b2lyIHVuIHRyYW5zZmVydCBkZSBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCB2ZXJzIGxlcyBzZXJ2ZXVycyBkZSBsYSBzb2Npw6l0w6kgR29vZ2xlIExMQywgMTYwMCBBbXBoaXRoZWF0cmUgUGFya3dheSwgOTQwNDMgTW91bnRhaW4gVmlldywgw4l0YXRzLVVuaXMuICAgCgpMb3JzcXVlIHR1IHV0aWxpc2VzIGxlIHNlcnZpY2UgR29vZ2xlIHN1ciBub3RyZSBzaXRlIHdlYiwgR29vZ2xlIHBldXQsIGxlIGNhcyDDqWNow6lhbnQsIHRyYW5zbWV0dHJlIGV0IHRyYWl0ZXIgZGVzIGluZm9ybWF0aW9ucyBwcm92ZW5hbnQgZCdhdXRyZXMgc2VydmljZXMgR29vZ2xlIGFmaW4gZGUgZm91cm5pciBkZXMgc2VydmljZXMgZW4gYXJyacOocmUtcGxhbiBwb3VyIGwnYWZmaWNoYWdlIGV0IGxlIHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzIGRlcyBzZXJ2aWNlcyBwcm9wb3PDqXMgcGFyIEdvb2dsZS4gw4AgY2V0dGUgZmluLCBpbCBwZXV0IMOpZ2FsZW1lbnQgeSBhdm9pciB1biB0cmFuc2ZlcnQgZGUgZG9ubsOpZXMgdmVycyBsZXMgc2VydmljZXMgR29vZ2xlIENsb3VkLCBHb29nbGUgTWFwcywgR29vZ2xlIEFkcyBldCBHb29nbGUgRm9udHMsIGNvbmZvcm3DqW1lbnQgw6AgbGEgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kgZGUgR29vZ2xlLCBzb3VzIGxhIHJlc3BvbnNhYmlsaXTDqSBkZSBHb29nbGUgZW4gbWF0acOocmUgZGUgcHJvdGVjdGlvbiBkZXMgZG9ubsOpZXMuIAoKVHUgcGV1eCBjb25zdWx0ZXIgbGEgY2VydGlmaWNhdGlvbiBkdSBwcmVzdGF0YWlyZSBkYW5zIGxlIGNhZHJlIGR1IGRpc3Bvc2l0aWYgZGUgcHJvdGVjdGlvbiBkZXMgZG9ubsOpZXMgVUUtw4l0YXRzLVVuaXMgc3VyIDxhIGhyZWY9Imh0dHBzOi8vd3d3LmRhdGFwcml2YWN5ZnJhbWV3b3JrLmdvdi9saXN0IiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL3d3dy5kYXRhcHJpdmFjeWZyYW1ld29yay5nb3YvbGlzdDwvYT4uPC9wPgo8cD5UdSBwZXV4IHJldGlyZXIgdG9uIGNvbnNlbnRlbWVudCDDoCB0b3V0IG1vbWVudC4KVHUgdHJvdXZlcmFzIHBsdXMgZCdpbmZvcm1hdGlvbnMgc3VyIGxlIHJldHJhaXQgZGUgdG9uIGNvbnNlbnRlbWVudCBzb2l0IGRhbnMgbGUgZm9ybXVsYWlyZSBkZSBjb25zZW50ZW1lbnQgbHVpLW3Dqm1lLCBzb2l0IMOgIGxhIGZpbiBkZSBsYSBwcsOpc2VudGUgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kuPC9wPgo8cD5Qb3VyIHBsdXMgZCdpbmZvcm1hdGlvbnMgc3VyIGxlIHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzIHRyYW5zbWlzZXMsIGNvbnN1bHRlIGxhIHBvbGl0aXF1ZSBkZSBjb25maWRlbnRpYWxpdMOpIGR1IGZvdXJuaXNzZXVyIMOgIGwnYWRyZXNzZSA8YSBocmVmPSJodHRwczovL3BvbGljaWVzLmdvb2dsZS5jb20vcHJpdmFjeSIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly9wb2xpY2llcy5nb29nbGUuY29tL3ByaXZhY3k8L2E+LjwvcD4KPHA+TGUgZm91cm5pc3NldXIgcHJvcG9zZSDDqWdhbGVtZW50IHVuZSBvcHRpb24gZGUgZMOpc2luc2NyaXB0aW9uIHN1ciA8YSBocmVmPSJodHRwczovL3N1cHBvcnQuZ29vZ2xlLmNvbS9NeS1BZC1DZW50ZXItSGVscC9hbnN3ZXIvMTIxNTU0NTE\/aGw9ZGUiIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPmh0dHBzOi8vc3VwcG9ydC5nb29nbGUuY29tL015LUFkLUNlbnRlci1IZWxwL2Fuc3dlci8xMjE1NTQ1MT9obD1kZTwvYT4uPC9wPjwvbGk+CjxsaT48aDMgaWQ9ImpzZWN0aW9uYW5hbWV0cmFja2VyMTA2YWdvb2dsZWZvbnRzIj48YSBuYW1lPSJ0cmFja2VyLTEwNiI+PC9hPiAgR29vZ2xlIEZvbnRzPC9oMz4KPHA+U3VyIG5vdHJlIHNpdGUsIG9uIHV0aWxpc2UgbGUgc2VydmljZSBHb29nbGUgRm9udHMgZGUgbGEgc29jacOpdMOpIEdvb2dsZSBJcmVsYW5kIExpbWl0ZWQsIEdvcmRvbiBIb3VzZSwgQmFycm93IFN0cmVldCwgNCBEdWJsaW4sIElybGFuZGUsIGUtbWFpbCA6IDxhIGhyZWY9Im1haWx0bzpzdXBwb3J0LWRldXRzY2hsYW5kQGdvb2dsZS5jb20iIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPnN1cHBvcnQtZGV1dHNjaGxhbmRAZ29vZ2xlLmNvbTwvYT4sIHNpdGUgd2ViIDogPGEgaHJlZj0iaHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS8iIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPmh0dHBzOi8vd3d3Lmdvb2dsZS5jb20vPC9hPi4KTGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIHNvbnQgw6lnYWxlbWVudCB0cmFuc2bDqXLDqWVzIHZlcnMgbGVzIMOJdGF0cy1VbmlzLgpFbiBjZSBxdWkgY29uY2VybmUgbGUgdHJhbnNmZXJ0IGRlIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIHZlcnMgbGVzIMOJdGF0cy1VbmlzLCBpbCBleGlzdGUgdW5lIGTDqWNpc2lvbiBkJ2Fkw6lxdWF0aW9uIHJlbGF0aXZlIGF1IGNhZHJlIGRlIHByb3RlY3Rpb24gZGVzIGRvbm7DqWVzIFVFLcOJdGF0cy1VbmlzIChFVS1VUyBEYXRhIFByaXZhY3kgRnJhbWV3b3JrKSBkZSBsYSBDb21taXNzaW9uIGV1cm9ww6llbm5lIGF1IHNlbnMgZGUgbCdhcnRpY2xlIDQ1IGR1IFJHUEQgKGNpLWFwcsOocyA6IERQRiAtIDxhIGhyZWY9Imh0dHBzOi8vY29tbWlzc2lvbi5ldXJvcGEuZXUvZG9jdW1lbnQvZmEwOWNiYWQtZGQ3ZC00Njg0LWFlNjAtYmUwM2ZjYjBmZGRmX2VuIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL2NvbW1pc3Npb24uZXVyb3BhLmV1L2RvY3VtZW50L2ZhMDljYmFkLWRkN2QtNDY4NC1hZTYwLWJlMDNmY2IwZmRkZl9lbjwvYT4gKS4KTCdleHBsb2l0YW50IGR1IHNlcnZpY2UgZXN0IGNlcnRpZmnDqSBkYW5zIGxlIGNhZHJlIGR1IERQRiwgY2UgcXVpIHNpZ25pZmllIHF1ZSBsZSBuaXZlYXUgZGUgcHJvdGVjdGlvbiBoYWJpdHVlbCBkdSBSR1BEIHMnYXBwbGlxdWUgw6AgY2UgdHJhbnNmZXJ0LjwvcD4KPHA+TGEgYmFzZSBqdXJpZGlxdWUgZHUgdHJhaXRlbWVudCBkZSB0ZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgZXN0IHRvbiBjb25zZW50ZW1lbnQsIGNvbmZvcm3DqW1lbnQgw6AgbCdhcnRpY2xlIDYsIHBhcmFncmFwaGUgMSwgcG9pbnQgYSkgZHUgUkdQRCBvdSDDoCBsJ2FydGljbGUgOSwgcGFyYWdyYXBoZSAyLCBwb2ludCBhKSBkdSBSR1BELCBxdWUgdHUgYXMgZG9ubsOpIHN1ciBub3RyZSBzaXRlIEludGVybmV0LiAgICAgPC9wPgo8cD5PbiB1dGlsaXNlIGxlIHNlcnZpY2UgR29vZ2xlIEZvbnRzIHBvdXIgaW50w6lncmVyIGRlcyBwb2xpY2VzIGRlIGNhcmFjdMOocmVzIGF0dHJheWFudGVzIHN1ciBub3RyZSBzaXRlLCBhZmluIGRlIHRlIHByb3Bvc2VyIHVuZSB2ZXJzaW9uIHBsdXMgYWdyw6lhYmxlIHZpc3VlbGxlbWVudCBkZSBub3RyZSBzaXRlIHdlYi4gQ2Ugc2VydmljZSBwZXV0IMOpZ2FsZW1lbnQgw6p0cmUgdXRpbGlzw6kgc3VyIG5vdHJlIHNpdGUgd2ViIGxvcnNxdWUgZCdhdXRyZXMgc2VydmljZXMgR29vZ2xlIHkgc29udCBjaGFyZ8OpcyBldCBuw6ljZXNzaXRlbnQgbGVzIHBvbGljZXMgR29vZ2xlIEZvbnRzIHBvdXIgZm9uY3Rpb25uZXIuIEMnZXN0IHBhciBleGVtcGxlIGxlIGNhcyBsb3JzcXVlIG5vdHJlIHNpdGUgd2ViIHV0aWxpc2UgZGVzIHNlcnZpY2VzIEdvb2dsZSBxdWkgb250IGltcMOpcmF0aXZlbWVudCBiZXNvaW4gZGUgR29vZ2xlIEZvbnRzIHBvdXIgZm9uY3Rpb25uZXIuICA8L3A+CjxwPlBvdXIgbGUgdHJhaXRlbWVudCBsdWktbcOqbWUsIGxlIHNlcnZpY2Ug4oCTIG91IHBsdXTDtHQgbm91cyDigJMgY29sbGVjdG9ucyBsZXMgZG9ubsOpZXMgc3VpdmFudGVzIDoKZGVzIGRvbm7DqWVzIHN1ciBsZXMgcG9saWNlcyBkZSBjYXJhY3TDqHJlcywgbCdhZHJlc3NlIElQIGR1IHZpc2l0ZXVyIGR1IHNpdGUsIGRlcyBzdGF0aXN0aXF1ZXMgc3VyIGwndXRpbGlzYXRpb24gZGVzIHBvbGljZXMgZGUgY2FyYWN0w6hyZXMgZXQgZCdhdXRyZXMgZG9ubsOpZXMgcHJvdmVuYW50IGRlcyBzZXJ2aWNlcyBHb29nbGUgbGnDqWVzIMOgIG5vdHJlIHNpdGUgd2ViLjwvcD4KPHA+U2kgbGUgc2VydmljZSBlc3QgYWN0aXbDqSBzdXIgbm90cmUgc2l0ZSB3ZWIsIGNlbHVpLWNpIMOpdGFibGl0IHVuZSBjb25uZXhpb24gYXZlYyBsZXMgc2VydmV1cnMgZGUgbGEgc29jacOpdMOpIEdvb2dsZSBJcmVsYW5kIExpbWl0ZWQgZXQgdHJhbnNtZXQgbGVzIGRvbm7DqWVzIG7DqWNlc3NhaXJlcy4gRGFucyBsZSBjYWRyZSBkdSB0cmFpdGVtZW50IGRlcyBjb21tYW5kZXMsIGlsIHBldXQgw6lnYWxlbWVudCB5IGF2b2lyIHVuIHRyYW5zZmVydCBkZSBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCB2ZXJzIGxlcyBzZXJ2ZXVycyBkZSBsYSBzb2Npw6l0w6kgR29vZ2xlIExMQywgMTYwMCBBbXBoaXRoZWF0cmUgUGFya3dheSwgOTQwNDMgTW91bnRhaW4gVmlldywgw4l0YXRzLVVuaXMuICAgCgpMb3JzcXVlIHR1IHV0aWxpc2VzIGxlIHNlcnZpY2UgR29vZ2xlIHN1ciBub3RyZSBzaXRlIHdlYiwgR29vZ2xlIHBldXQsIGxlIGNhcyDDqWNow6lhbnQsIHJlY2V2b2lyIGV0IHRyYWl0ZXIgZGVzIGluZm9ybWF0aW9ucyBwcm92ZW5hbnQgZCdhdXRyZXMgc2VydmljZXMgR29vZ2xlIGFmaW4gZGUgZm91cm5pciBkZXMgc2VydmljZXMgZW4gYXJyacOocmUtcGxhbiBwb3VyIGwnYWZmaWNoYWdlIGV0IGxlIHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzIGRlcyBzZXJ2aWNlcyBwcm9wb3PDqXMgcGFyIEdvb2dsZS4gw4AgY2V0dGUgZmluLCBpbCBwZXV0IMOpZ2FsZW1lbnQgeSBhdm9pciB1biB0cmFuc2ZlcnQgZGUgZG9ubsOpZXMgdmVycyBsZXMgc2VydmljZXMgR29vZ2xlIEFQSSwgR29vZ2xlIENsb3VkIGV0IEdvb2dsZSBBZHMsIGNvbmZvcm3DqW1lbnQgw6AgbGEgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kgZGUgR29vZ2xlLiAKClR1IHBldXggY29uc3VsdGVyIGxhIGNlcnRpZmljYXRpb24gZHUgcHJlc3RhdGFpcmUgZGFucyBsZSBjYWRyZSBkdSBjYWRyZSBkZSBwcm90ZWN0aW9uIGRlcyBkb25uw6llcyBVRS3DiXRhdHMtVW5pcyDDoCBsJ2FkcmVzc2UgPGEgaHJlZj0iaHR0cHM6Ly93d3cuZGF0YXByaXZhY3lmcmFtZXdvcmsuZ292L2xpc3QiIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPmh0dHBzOi8vd3d3LmRhdGFwcml2YWN5ZnJhbWV3b3JrLmdvdi9saXN0PC9hPi48L3A+CjxwPlR1IHBldXggcmV0aXJlciB0b24gY29uc2VudGVtZW50IMOgIHRvdXQgbW9tZW50LgpUdSB0cm91dmVyYXMgcGx1cyBkJ2luZm9ybWF0aW9ucyBzdXIgbGUgcmV0cmFpdCBkZSB0b24gY29uc2VudGVtZW50IHNvaXQgZGFucyBsZSBmb3JtdWxhaXJlIGRlIGNvbnNlbnRlbWVudCBsdWktbcOqbWUsIHNvaXQgw6AgbGEgZmluIGRlIGxhIHByw6lzZW50ZSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqS48L3A+CjxwPlBvdXIgcGx1cyBkJ2luZm9ybWF0aW9ucyBzdXIgbGUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgdHJhbnNtaXNlcywgY29uc3VsdGUgbGEgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kgZHUgZm91cm5pc3NldXIgw6AgbCdhZHJlc3NlIDxhIGhyZWY9Imh0dHBzOi8vcG9saWNpZXMuZ29vZ2xlLmNvbS9wcml2YWN5IiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL3BvbGljaWVzLmdvb2dsZS5jb20vcHJpdmFjeTwvYT4uPC9wPgo8cD5MZSBmb3Vybmlzc2V1ciBwcm9wb3NlIMOpZ2FsZW1lbnQgdW5lIG9wdGlvbiBkZSBkw6lzaW5zY3JpcHRpb24gc3VyIDxhIGhyZWY9Imh0dHBzOi8vc3VwcG9ydC5nb29nbGUuY29tL015LUFkLUNlbnRlci1IZWxwL2Fuc3dlci8xMjE1NTQ1MT9obD1kZSIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly9zdXBwb3J0Lmdvb2dsZS5jb20vTXktQWQtQ2VudGVyLUhlbHAvYW5zd2VyLzEyMTU1NDUxP2hsPWRlPC9hPi48L3A+PC9saT4KPGxpPjxoMyBpZD0ianNlY3Rpb25hbmFtZXRyYWNrZXIwMTFiMmJhZTc2MzA0Nzk1ODliZTVhZmFjNzI0MWU4MGFqb3Rmb3JtIj48YSBuYW1lPSJ0cmFja2VyLTAxMWIyYmFlLTc2MzAtNDc5NS04OWJlLTVhZmFjNzI0MWU4MCI+PC9hPiAgSm90Rm9ybTwvaDM+CjxwPlN1ciBub3RyZSBzaXRlLCBvbiB1dGlsaXNlIGxlIHNlcnZpY2UgSm90Rm9ybSBkZSBsYSBzb2Npw6l0w6kgSm90Rm9ybSBJbmMuLCA0IEVtYmFyY2FkZXJvIENlbnRlciwgU3VpdGUgNzgwLCA5NDExMSBTYW4gRnJhbmNpc2NvLCDDiXRhdHMtVW5pcywgZS1tYWlsIDogPGEgaHJlZj0ibWFpbHRvOnByaXZhY3lAam90Zm9ybS5jb20iIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPnByaXZhY3lAam90Zm9ybS5jb208L2E+LCBzaXRlIHdlYiA6IDxhIGhyZWY9Imh0dHBzOi8vd3d3LmpvdGZvcm0uY29tLyIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly93d3cuam90Zm9ybS5jb20vPC9hPi4KTGUgdHJhbnNmZXJ0IHMnZWZmZWN0dWUgw6lnYWxlbWVudCB2ZXJzIHVuIHBheXMgdGllcnMgcG91ciBsZXF1ZWwgaWwgbidleGlzdGUgcGFzIGRlIGTDqWNpc2lvbiBkJ2Fkw6lxdWF0aW9uIGRlIGxhIENvbW1pc3Npb24uClBhciBjb25zw6lxdWVudCwgbGUgbml2ZWF1IGRlIHByb3RlY3Rpb24gaGFiaXR1ZWwgcHLDqXZ1IHBhciBsZSBSR1BEIG5lIHBldXQgw6p0cmUgZ2FyYW50aSBsb3JzIGR1IHRyYW5zZmVydCwgY2FyIG9uIG5lIHBldXQgZXhjbHVyZSBxdWUsIGRhbnMgY2UgcGF5cyB0aWVycywgbGVzIGF1dG9yaXTDqXMsIHBhciBleGVtcGxlLCBwdWlzc2VudCBhdm9pciBhY2PDqHMgYXV4IGRvbm7DqWVzIGNvbGxlY3TDqWVzLiA8L3A+CjxwPkxhIGJhc2UganVyaWRpcXVlIGR1IHRyYWl0ZW1lbnQgZGUgdGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIGVzdCB0b24gY29uc2VudGVtZW50LCBjb25mb3Jtw6ltZW50IMOgIGwnYXJ0aWNsZSA2LCBwYXJhZ3JhcGhlIDEsIHBvaW50IGEpIGR1IFJHUEQgb3Ugw6AgbCdhcnRpY2xlIDksIHBhcmFncmFwaGUgMiwgcG9pbnQgYSkgZHUgUkdQRCwgcXVlIHR1IGFzIGRvbm7DqSBzdXIgbm90cmUgc2l0ZSBJbnRlcm5ldC4gICAgIDwvcD4KPHA+TGUgcGx1Z2luIEpvdEZvcm0gcGVybWV0IGF1eCB1dGlsaXNhdGV1cnMgZGUgY3LDqWVyIGRlcyBmb3JtdWxhaXJlcyBwZXJzb25uYWxpc8OpcyBldCBkZSBsZXMgaW50w6lncmVyIGZhY2lsZW1lbnQgw6AgbGV1cnMgc2l0ZXMgd2ViIG91IMOgIGxldXJzIHBsYXRlZm9ybWVzIGVuIGxpZ25lLiBJbCBmYWNpbGl0ZSBsYSBjb2xsZWN0ZSBkZSBkb25uw6llcywgbGEgcmVjdWVpbGxlIGRlIHJldG91cnMgZCdleHDDqXJpZW5jZSBldCBsJ2F1dG9tYXRpc2F0aW9uIGRlcyBwcm9jZXNzdXMgcG91ciBsZXMgZW50cmVwcmlzZXMgZXQgbGVzIG9yZ2FuaXNhdGlvbnMuIDwvcD4KPHA+VHUgcGV1eCByZXRpcmVyIHRvbiBjb25zZW50ZW1lbnQgw6AgdG91dCBtb21lbnQuClR1IHRyb3V2ZXJhcyBwbHVzIGQnaW5mb3JtYXRpb25zIHN1ciBsZSByZXRyYWl0IGRlIHRvbiBjb25zZW50ZW1lbnQgc29pdCBkYW5zIGxlIGZvcm11bGFpcmUgZGUgY29uc2VudGVtZW50IGx1aS1tw6ptZSwgc29pdCDDoCBsYSBmaW4gZGUgY2V0dGUgcG9saXRpcXVlIGRlIGNvbmZpZGVudGlhbGl0w6kuPC9wPgo8cD5Qb3VyIHBsdXMgZCdpbmZvcm1hdGlvbnMgc3VyIGxlIHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzIHRyYW5zbWlzZXMsIGNvbnN1bHRlIGxhIHBvbGl0aXF1ZSBkZSBjb25maWRlbnRpYWxpdMOpIGR1IGZvdXJuaXNzZXVyIMOgIGwnYWRyZXNzZSA8YSBocmVmPSJodHRwczovL3d3dy5qb3Rmb3JtLmNvbS9wcml2YWN5LyIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly93d3cuam90Zm9ybS5jb20vcHJpdmFjeS88L2E+LjwvcD48L2xpPgoKCjxsaT48aDMgaWQ9ImpzZWN0aW9uYW5hbWV0cmFja2VyMTgxYXBheXBhbCI+PGEgbmFtZT0idHJhY2tlci0xODEiPjwvYT4gIFBheVBhbDwvaDM+CjxwPlN1ciBub3RyZSBzaXRlLCBvbiB1dGlsaXNlIGxlIHNlcnZpY2UgUGF5UGFsIGRlIGxhIHNvY2nDqXTDqSBQYXlQYWwgKEV1cm9wZSkgUy7DoCByLmwuIGV0IENpZSwgUy5DLkEuLCAyMi0yNCBCb3VsZXZhcmQgUm95YWwsIDI0NDkgTHV4ZW1ib3VyZywgTHV4ZW1ib3VyZy4KTGVzIGRvbm7DqWVzIHBlcnNvbm5lbGxlcyBzb250IHRyYW5zbWlzZXMgZXhjbHVzaXZlbWVudCDDoCBkZXMgc2VydmV1cnMgc2l0dcOpcyBkYW5zIGwnVW5pb24gZXVyb3DDqWVubmUuPC9wPgo8cD5Db25mb3Jtw6ltZW50IMOgIGwnYXJ0aWNsZSA2LCBwYXJhZ3JhcGhlIDEsIHBvaW50IGIpIGR1IFJHUEQsIGxhIGJhc2UganVyaWRpcXVlIGR1IHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIGVzdCBsZSBjb250cmF0IGTDqWrDoCBjb25jbHUgb3Ugw6AgY29uY2x1cmUgZW50cmUgdG9pIGV0IG5vdXMuICAgPC9wPgo8cD5PbiB1dGlsaXNlIGNlIHNlcnZpY2UgcG91ciBhZmZpY2hlciBsZSBib3V0b24gUGF5UGFsIHN1ciBjaGFxdWUgcGFnZSBkZSBub3RyZSBib3V0aXF1ZSBlbiBsaWduZSwgcG91ciBxdWUgdHUgc2FjaGVzIHF1ZWxzIG1veWVucyBkZSBwYWllbWVudCB0dSBwZXV4IHV0aWxpc2VyIGNoZXogbm91cy48L3A+CjxwPkVuIHZlcnR1IGR1IGNvbnRyYXQgY29uY2x1IGVudHJlIHRvaSBldCBQYXlQYWwsIGVuIGNhcyBkZSBwYWllbWVudCB2aWEgUGF5UGFsLCBkZXMgZG9ubsOpZXMgcGV1dmVudCDDqnRyZSB0cmFuc21pc2VzIMOgIGRlcyBzb2Npw6l0w6lzIGFmZmlsacOpZXMgw6AgUGF5UGFsLiBDZWxsZXMtY2kgcGV1dmVudCDDqWdhbGVtZW50IMOqdHJlIHNpdHXDqWVzIGF1eCDDiXRhdHMtVW5pcywgYydlc3QgcG91cnF1b2kgb24gbmUgcGV1dCBwYXMgZXhjbHVyZSBxdWUgbGVzIGF1dG9yaXTDqXMgYW3DqXJpY2FpbmVzIHB1aXNzZW50IGF2b2lyIGFjY8OocyDDoCB0ZXMgZG9ubsOpZXMuIDwvcD4KPHA+VHUgdHJvdXZlcmFzIMOgIGxhIGZpbiBkZSBjZXR0ZSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqSBsZXMgZHJvaXRzIGRvbnQgdHUgZGlzcG9zZXMgZW4gbWF0acOocmUgZGUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMuPC9wPgo8cD5Qb3VyIHBsdXMgZCdpbmZvcm1hdGlvbnMgc3VyIGxlIHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzIHRyYW5zbWlzZXMsIGNvbnN1bHRlIGxhIHBvbGl0aXF1ZSBkZSBjb25maWRlbnRpYWxpdMOpIGR1IGZvdXJuaXNzZXVyIMOgIGwnYWRyZXNzZSA8YSBocmVmPSJodHRwczovL3d3dy5wYXlwYWwuY29tL2RlL3dlYmFwcHMvbXBwL3VhL3ByaXZhY3ktZnVsbD9sb2NhbGUueD1kZV9ERSIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly93d3cucGF5cGFsLmNvbS9kZS93ZWJhcHBzL21wcC91YS9wcml2YWN5LWZ1bGw\/bG9jYWxlLng9ZGVfREU8L2E+LjwvcD48L2xpPgoKCjxsaT48aDMgaWQ9ImpzZWN0aW9uYW5hbWV0cmFja2VyMTIwMGFyZWNodHN0ZXh0c25pcHBldHVuZG1vZHVsZSI+PGEgbmFtZT0idHJhY2tlci0xMjAwIj48L2E+ICBFeHRyYWl0cyBkZSB0ZXh0ZXMganVyaWRpcXVlcyBldCBtb2R1bGVzPC9oMz4KPHA+U3VyIG5vdHJlIHNpdGUsIG9uIHV0aWxpc2UgbGUgc2VydmljZSDCqyBSZWNodHN0ZXh0c25pcHBldCDCuyBhaW5zaSBxdWUgZGVzIG1vZHVsZXMgZGUgbGEgc29jacOpdMOpIFdlYnNpdGUtQ2hlY2sgR21iSCwgQmVldGhvdmVuc3RyYcOfZSAyNCwgNjYxMTEgU2FycmVicnVjaywgQWxsZW1hZ25lLCBlLW1haWwgOiA8YSBocmVmPSJtYWlsdG86c3VwcG9ydEB3ZWJzaXRlLWNoZWNrLmRlIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5zdXBwb3J0QHdlYnNpdGUtY2hlY2suZGU8L2E+LCBzaXRlIHdlYiA6IDxhIGhyZWY9Imh0dHBzOi8vd3d3LndlYnNpdGUtY2hlY2suZGUvIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL3d3dy53ZWJzaXRlLWNoZWNrLmRlLzwvYT4uCkxlcyBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCBzb250IHRyYW5zbWlzZXMgZXhjbHVzaXZlbWVudCDDoCBkZXMgc2VydmV1cnMgc2l0dcOpcyBkYW5zIGwnVW5pb24gZXVyb3DDqWVubmUuPC9wPgo8cD5MYSBiYXNlIGp1cmlkaXF1ZSBkdSB0cmFpdGVtZW50IGVzdCBsJ2FydGljbGUgNiwgcGFyYWdyYXBoZSAxLCBwb2ludCBjKSBkdSBSR1BELgpMJ3V0aWxpc2F0aW9uIGRlIGNlIHNlcnZpY2Ugbm91cyBhaWRlIMOgIHJlc3BlY3RlciBub3Mgb2JsaWdhdGlvbnMgbMOpZ2FsZXMuICA8L3A+CjxwPkNlIHNlcnZpY2UgcGVybWV0IGRlIGNoYXJnZXIgbGVzIGNvbnRlbnVzIGRlIG5vcyB0ZXh0ZXMganVyaWRpcXVlcyBzdXIgbm90cmUgc2l0ZSBJbnRlcm5ldC4gR3LDomNlIMOgIGwnaW50w6lncmF0aW9uIG1pc2UgZW4gcGxhY2Ugc3VyIG5vdHJlIHNpdGUsIGxlcyB0ZXh0ZXMganVyaWRpcXVlcyBsZXMgcGx1cyByw6ljZW50cyBzb250IGNoYXJnw6lzLiBDZXR0ZSBpbnTDqWdyYXRpb24gcGVybWV0IMOpZ2FsZW1lbnQsIGxlIGNhcyDDqWNow6lhbnQsIGRlIGNoYXJnZXIgZCdhdXRyZXMgbW9kdWxlcyB0ZWNobmlxdWVzIGxpw6lzIGF1eCB0ZXh0ZXMganVyaWRpcXVlcyBvdSBhdXggw6lsw6ltZW50cyByZXF1aXMgcGFyIGxhIGxvaS4gIDwvcD4KPHA+VHUgdHJvdXZlcmFzIMOgIGxhIGZpbiBkZSBjZXR0ZSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqSBsZXMgZHJvaXRzIGRvbnQgdHUgZGlzcG9zZXMgZW4gbWF0acOocmUgZGUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMuPC9wPgo8cD5Qb3VyIHBsdXMgZCdpbmZvcm1hdGlvbnMgc3VyIGxlIHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzIHRyYW5zbWlzZXMsIGNvbnN1bHRlIGxhIHBvbGl0aXF1ZSBkZSBjb25maWRlbnRpYWxpdMOpIGR1IGZvdXJuaXNzZXVyIMOgIGwnYWRyZXNzZSA8YSBocmVmPSJodHRwczovL3d3dy53ZWJzaXRlLWNoZWNrLmRlL2RhdGVuc2NodXR6ZXJrbGFlcnVuZy8iIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPmh0dHBzOi8vd3d3LndlYnNpdGUtY2hlY2suZGUvZGF0ZW5zY2h1dHplcmtsYWVydW5nLzwvYT4uPC9wPjwvbGk+CgoKPGxpPjxoMyBpZD0ianNlY3Rpb25hbmFtZXRyYWNrZXIzN2JhNzE4MjUzYzk0OGI2YTQ0OWM0MTNjYjQ1MTcxZGFoY2FwdGNoYSI+PGEgbmFtZT0idHJhY2tlci0zN2JhNzE4Mi01M2M5LTQ4YjYtYTQ0OS1jNDEzY2I0NTE3MWQiPjwvYT4gIGhjYXB0Y2hhPC9oMz4KPHA+U3VyIG5vdHJlIHNpdGUsIG9uIHV0aWxpc2UgbGUgc2VydmljZSBoY2FwdGNoYSBkZSBsYSBzb2Npw6l0w6kgSW50dWl0aW9uIE1hY2hpbmVzLCBJbmMuLCAyMjExIFNlbGlnIERyaXZlLCA5MDAyNiBMb3MgQW5nZWxlcywgw4l0YXRzLVVuaXMsIGUtbWFpbCA6IDxhIGhyZWY9Im1haWx0bzpzdXBwb3J0QGltYWNoaW5lcy5jb20iIHJlbD0ibm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPnN1cHBvcnRAaW1hY2hpbmVzLmNvbTwvYT4sIHNpdGUgd2ViIDogPGEgaHJlZj0iaHR0cHM6Ly93d3cuaGNhcHRjaGEuY29tLyIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly93d3cuaGNhcHRjaGEuY29tLzwvYT4uCkxlcyBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCBzb250IMOpZ2FsZW1lbnQgdHJhbnNmw6lyw6llcyB2ZXJzIGxlcyDDiXRhdHMtVW5pcy4KRW4gY2UgcXVpIGNvbmNlcm5lIGxlIHRyYW5zZmVydCBkZSBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCB2ZXJzIGxlcyDDiXRhdHMtVW5pcywgaWwgZXhpc3RlIHVuZSBkw6ljaXNpb24gZCdhZMOpcXVhdGlvbiByZWxhdGl2ZSBhdSBjYWRyZSBkZSBwcm90ZWN0aW9uIGRlcyBkb25uw6llcyBVRS3DiXRhdHMtVW5pcyAoRVUtVVMgRGF0YSBQcml2YWN5IEZyYW1ld29yaykgZGUgbGEgQ29tbWlzc2lvbiBldXJvcMOpZW5uZSBhdSBzZW5zIGRlIGwnYXJ0aWNsZSA0NSBkdSBSR1BEIChjaS1hcHLDqHMgOiBEUEYgLSA8YSBocmVmPSJodHRwczovL2NvbW1pc3Npb24uZXVyb3BhLmV1L2RvY3VtZW50L2ZhMDljYmFkLWRkN2QtNDY4NC1hZTYwLWJlMDNmY2IwZmRkZl9lbiIgcmVsPSJub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly9jb21taXNzaW9uLmV1cm9wYS5ldS9kb2N1bWVudC9mYTA5Y2JhZC1kZDdkLTQ2ODQtYWU2MC1iZTAzZmNiMGZkZGZfZW48L2E+ICkuCkwnZXhwbG9pdGFudCBkdSBzZXJ2aWNlIGVzdCBjZXJ0aWZpw6kgZGFucyBsZSBjYWRyZSBkdSBEUEYsIGNlIHF1aSBzaWduaWZpZSBxdWUgbGUgbml2ZWF1IGRlIHByb3RlY3Rpb24gaGFiaXR1ZWwgZHUgUkdQRCBzJ2FwcGxpcXVlIMOgIGNlIHRyYW5zZmVydC48L3A+CjxwPkxhIGJhc2UganVyaWRpcXVlIGR1IHRyYWl0ZW1lbnQgZGUgdGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIGVzdCB0b24gY29uc2VudGVtZW50LCBjb25mb3Jtw6ltZW50IMOgIGwnYXJ0aWNsZSA2LCBwYXJhZ3JhcGhlIDEsIHBvaW50IGEpIGR1IFJHUEQgb3Ugw6AgbCdhcnRpY2xlIDksIHBhcmFncmFwaGUgMiwgcG9pbnQgYSkgZHUgUkdQRCwgcXVlIHR1IGFzIGRvbm7DqSBzdXIgbm90cmUgc2l0ZSBJbnRlcm5ldC4gICAgIDwvcD4KPHA+R3LDomNlIGF1IHNlcnZpY2UgaGNhcHRjaGEsIG9uIHByb3TDqGdlIG5vdHJlIHNpdGUgd2ViLCBldCBub3RhbW1lbnQgbGVzIGZvcm11bGFpcmVzIGRlIHNhaXNpZSBxdSdvbiB5IHByb3Bvc2UgKGNvbW1lIGxlcyBmb3JtdWxhaXJlcyBkZSBjb250YWN0KSwgY29udHJlIGxlcyBib3RzIGV0IGxlcyBjeWJlcmF0dGFxdWVzLiBQb3VyIMOnYSwgYXZhbnQgZCd1dGlsaXNlciBub3MgZm9ybXVsYWlyZXMgZGUgc2Fpc2llLCBsZSBjbGllbnQgZG9pdCByw6lzb3VkcmUgdW4gY2FwdGNoYSBwb3VyIHByb3V2ZXIgcXUnaWwgZXN0IGJpZW4gdW5lIHBlcnNvbm5lLCBvdSBiaWVuIGlsIGZhaXQgbCdvYmpldCBkJ3VuZSB2w6lyaWZpY2F0aW9uIGF1dG9tYXRpcXVlLiA8L3A+CjxwPlR1IHBldXggcmV0aXJlciB0b24gY29uc2VudGVtZW50IMOgIHRvdXQgbW9tZW50LgpUdSB0cm91dmVyYXMgcGx1cyBkJ2luZm9ybWF0aW9ucyBzdXIgbGUgcmV0cmFpdCBkZSB0b24gY29uc2VudGVtZW50IHNvaXQgZGFucyBsZSBmb3JtdWxhaXJlIGRlIGNvbnNlbnRlbWVudCBsdWktbcOqbWUsIHNvaXQgw6AgbGEgZmluIGRlIGNldHRlIHBvbGl0aXF1ZSBkZSBjb25maWRlbnRpYWxpdMOpLjwvcD4KPHA+UG91ciBwbHVzIGQnaW5mb3JtYXRpb25zIHN1ciBsZSB0cmFpdGVtZW50IGRlcyBkb25uw6llcyB0cmFuc21pc2VzLCBjb25zdWx0ZSBsYSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqSBkdSBmb3Vybmlzc2V1ciDDoCBsJ2FkcmVzc2UgPGEgaHJlZj0iaHR0cHM6Ly93d3cuaGNhcHRjaGEuY29tL3Rlcm1zIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5odHRwczovL3d3dy5oY2FwdGNoYS5jb20vdGVybXM8L2E+LjwvcD48L2xpPgo8L3VsPgo8ZGl2IGlkPSJqbWQtc2VjdGlvbi1jb29raWVzIiBkYXRhLW1hcmtkb3duPSIxIj48aDIgaWQ9ImpzZWN0aW9udW50ZXJyaWNodHVuZ2JlcmRpZW51dHp1bmd2b25jb29raWVzIj5JbmZvcm1hdGlvbnMgc3VyIGwndXRpbGlzYXRpb24gZGVzIGNvb2tpZXM8L2gyPgo8dWw+CjxsaT48aDQgaWQ9ImpzZWN0aW9ud2VsY2hlcGVyc29uZW5iZXpvZ2VuZW5kYXRlbndlcmRlbmVyaG9iZW51bmRpbndlbGNoZW11bWZhbmd3ZXJkZW5kaWVzZXZlcmFyYmVpdGV0Ij5RdWVsbGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIHNvbnQgY29sbGVjdMOpZXMgZXQgZGFucyBxdWVsbGUgbWVzdXJlIHNvbnQtZWxsZXMgdHJhaXTDqWVzID88L2g0Pgo8cD5TdXIgZGlmZsOpcmVudGVzIHBhZ2VzLCBvbiBpbnTDqGdyZSBldCB1dGlsaXNlIGRlcyBjb29raWVzIHBvdXIgcGVybWV0dHJlIGNlcnRhaW5lcyBmb25jdGlvbm5hbGl0w6lzIGRlIG5vdHJlIHNpdGUgd2ViIGV0IGludMOpZ3JlciBkZXMgc2VydmljZXMgd2ViIGV4dGVybmVzLgpDZXMgwqsgY29va2llcyDCuyBzb250IGRlIHBldGl0cyBmaWNoaWVycyB0ZXh0ZSBxdWUgdG9uIG5hdmlnYXRldXIgcGV1dCBlbnJlZ2lzdHJlciBzdXIgdG9uIGFwcGFyZWlsLgpDZXMgZmljaGllcnMgdGV4dGUgY29udGllbm5lbnQgdW5lIGNoYcOubmUgZGUgY2FyYWN0w6hyZXMgdW5pcXVlIHF1aSBpZGVudGlmaWUgZGUgbWFuacOocmUgdW5pdm9xdWUgbGUgbmF2aWdhdGV1ciBsb3JzcXVlIHR1IHJldmllbnMgc3VyIG5vdHJlIHNpdGUgd2ViLgpMZSBwcm9jZXNzdXMgZCdlbnJlZ2lzdHJlbWVudCBkJ3VuIGZpY2hpZXIgY29va2llIGVzdCDDqWdhbGVtZW50IGFwcGVsw6kgwqsgaW5zdGFsbGF0aW9uIGQndW4gY29va2llIMK7LgpMZXMgY29va2llcyBwZXV2ZW50IMOqdHJlIGluc3RhbGzDqXMgYXVzc2kgYmllbiBwYXIgbGUgc2l0ZSB3ZWIgbHVpLW3Dqm1lIHF1ZSBwYXIgZGVzIHNlcnZpY2VzIHdlYiBleHRlcm5lcy4KTGVzIGNvb2tpZXMgc29udCBpbnN0YWxsw6lzIHBhciBub3RyZSBzaXRlIHdlYiBvdSBwYXIgZGVzIHNlcnZpY2VzIHdlYiBleHRlcm5lcyBhZmluIGRlIGdhcmFudGlyIGxlIGJvbiBmb25jdGlvbm5lbWVudCBkZSBub3RyZSBzaXRlLCBk4oCZYW3DqWxpb3JlciBzb24gZXJnb25vbWllIG91IGRlIHBvdXJzdWl2cmUgbOKAmW9iamVjdGlmIHF1ZSB0dSBhcyBhY2NlcHTDqS4KTGEgdGVjaG5vbG9naWUgZGVzIGNvb2tpZXMgbm91cyBwZXJtZXQgw6lnYWxlbWVudCBkJ2lkZW50aWZpZXIgY2hhcXVlIHZpc2l0ZXVyIMOgIGwnYWlkZSBkZSBwc2V1ZG9ueW1lcywgcGFyIGV4ZW1wbGUgdW4gaWRlbnRpZmlhbnQgaW5kaXZpZHVlbCBvdSBhbMOpYXRvaXJlLCBjZSBxdWkgbm91cyBwZXJtZXQgZGUgcHJvcG9zZXIgZGVzIHNlcnZpY2VzIHBsdXMgcGVyc29ubmFsaXPDqXMuClR1IHRyb3V2ZXJhcyBwbHVzIGRlIGTDqXRhaWxzIGRhbnMgbGUgdGFibGVhdSBjaS1kZXNzb3VzLjwvcD48L2xpPgo8bGk+PGg0IGlkPSJqc2VjdGlvbnJlY2h0c2dydW5kbGFnZWZyZGlldmVyYXJiZWl0dW5ncGVyc29uZW5iZXpvZ2VuZXJkYXRlbiI+QmFzZSBqdXJpZGlxdWUgZHUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWw8L2g0Pgo8cD5EYW5zIGxhIG1lc3VyZSBvw7kgbGVzIGNvb2tpZXMgc29udCB0cmFpdMOpcyBzdXIgbGEgYmFzZSBkJ3VuIGNvbnNlbnRlbWVudCBjb25mb3Jtw6ltZW50IMOgIGwnYXJ0aWNsZSA2LCBwYXJhZ3JhcGhlIDEsIHBvaW50IGEpIGR1IFJHUEQsIGNlIGNvbnNlbnRlbWVudCB2YXV0IMOpZ2FsZW1lbnQgY29tbWUgY29uc2VudGVtZW50IGF1IHNlbnMgZGUgbCdhcnRpY2xlIDI1LCBwYXJhZ3JhcGhlIDEgZGUgbGEgVEREREcgcG91ciBsJ2luc3RhbGxhdGlvbiBkdSBjb29raWUgc3VyIGwnYXBwYXJlaWwgZGUgbCd1dGlsaXNhdGV1ci4KRGFucyBsYSBtZXN1cmUgb8O5IHVuZSBhdXRyZSBiYXNlIGp1cmlkaXF1ZSBlc3QgbWVudGlvbm7DqWUgY29uZm9ybcOpbWVudCBhdSBSR1BEIChwYXIgZXhlbXBsZSwgcG91ciBsJ2V4w6ljdXRpb24gZCd1biBjb250cmF0IG91IGxlIHJlc3BlY3QgZCdvYmxpZ2F0aW9ucyBsw6lnYWxlcyksIGwnZW5yZWdpc3RyZW1lbnQgb3UgbCdpbnN0YWxsYXRpb24gZHUgY29va2llIHNlIGZhaXQgc3VyIGxhIGJhc2UgZCd1bmUgZXhjZXB0aW9uIHByw6l2dWUgcGFyIGwnYXJ0aWNsZSAyNSwgcGFyYWdyYXBoZSAyLCBkZSBsYSBURERERy4KQ+KAmWVzdCBsZSBjYXMgwqsgbG9yc3F1ZSBsZSBzZXVsIGJ1dCBkdSBzdG9ja2FnZSBk4oCZaW5mb3JtYXRpb25zIHN1ciBsZSB0ZXJtaW5hbCBkZSBs4oCZdXRpbGlzYXRldXIgZmluYWwgb3UgbGUgc2V1bCBidXQgZGUgbOKAmWFjY8OocyDDoCBkZXMgaW5mb3JtYXRpb25zIGTDqWrDoCBzdG9ja8OpZXMgc3VyIGNlIHRlcm1pbmFsIGVzdCBk4oCZYXNzdXJlciBsYSB0cmFuc21pc3Npb24gZOKAmXVuIG1lc3NhZ2UgdmlhIHVuIHLDqXNlYXUgcHVibGljIGRlIHTDqWzDqWNvbW11bmljYXRpb25zIMK7Cm91IMKrIGxvcnNxdWUgbGUgc3RvY2thZ2UgZOKAmWluZm9ybWF0aW9ucyBkYW5zIGzigJnDqXF1aXBlbWVudCB0ZXJtaW5hbCBkZSBs4oCZdXRpbGlzYXRldXIgZmluYWwgb3UgbOKAmWFjY8OocyDDoCBkZXMgaW5mb3JtYXRpb25zIGTDqWrDoCBzdG9ja8OpZXMgZGFucyBjZXQgw6lxdWlwZW1lbnQgZXN0IGFic29sdW1lbnQgbsOpY2Vzc2FpcmUgcG91ciBxdWUgbGUgZm91cm5pc3NldXIgZOKAmXVuIHNlcnZpY2UgZGUgdMOpbMOpbcOpZGlhcyBwdWlzc2UgZm91cm5pciB1biBzZXJ2aWNlIGRlIHTDqWzDqW3DqWRpYXMgZXhwcmVzc8OpbWVudCBkZW1hbmTDqSBwYXIgbOKAmXV0aWxpc2F0ZXVyIMK7LgpMYSBiYXNlIGp1cmlkaXF1ZSBhcHBsaWNhYmxlIGVzdCBpbmRpcXXDqWUgZGFucyBsZSB0YWJsZWF1IHN1ciBsZXMgY29va2llcyBwcsOpc2VudMOpIHBsdXMgbG9pbiBkYW5zIGNldHRlIHJ1YnJpcXVlLiAgICA8L3A+PC9saT4KPGxpPjxoNCBpZD0ianNlY3Rpb256d2Vja2RlcmRhdGVudmVyYXJiZWl0dW5nIj5GaW5hbGl0w6kgZHUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXM8L2g0Pgo8cD5MZXMgY29va2llcyBzb250IGluc3RhbGzDqXMgcGFyIG5vdHJlIHNpdGUgd2ViIG91IHBhciBkZXMgc2VydmljZXMgd2ViIGV4dGVybmVzIGFmaW4gZGUgZ2FyYW50aXIgbGUgYm9uIGZvbmN0aW9ubmVtZW50IGRlIG5vdHJlIHNpdGUsIGQnYW3DqWxpb3JlciBzb24gZXJnb25vbWllIG91IGRlIHLDqXBvbmRyZSDDoCBsJ29iamVjdGlmIHF1ZSB0dSBhcyBhY2NlcHTDqS4KTGEgdGVjaG5vbG9naWUgZGVzIGNvb2tpZXMgbm91cyBwZXJtZXQgw6lnYWxlbWVudCBkJ2lkZW50aWZpZXIgY2hhcXVlIHZpc2l0ZXVyIMOgIGwnYWlkZSBkZSBwc2V1ZG9ueW1lcywgcGFyIGV4ZW1wbGUgdW4gaWRlbnRpZmlhbnQgaW5kaXZpZHVlbCBvdSBhbMOpYXRvaXJlLCBjZSBxdWkgbm91cyBwZXJtZXQgZGUgcHJvcG9zZXIgZGVzIHNlcnZpY2VzIHBsdXMgcGVyc29ubmFsaXPDqXMuClR1IHRyb3V2ZXJhcyBwbHVzIGRlIGTDqXRhaWxzIGRhbnMgbGUgdGFibGVhdSBjaS1kZXNzb3VzLjwvcD48L2xpPgo8bGk+PGg0IGlkPSJqc2VjdGlvbmRhdWVyZGVyc3BlaWNoZXJ1bmciPkR1csOpZSBkZSBjb25zZXJ2YXRpb248L2g0Pgo8cD5Ob3MgY29va2llcyBzb250IGNvbnNlcnbDqXMganVzcXUnw6AgY2UgcXVlIHR1IGxlcyBzdXBwcmltZXMgZGUgdG9uIG5hdmlnYXRldXIgb3UsIHMnaWwgcydhZ2l0IGQndW4gY29va2llIGRlIHNlc3Npb24sIGp1c3F1J8OgIGwnZXhwaXJhdGlvbiBkZSBsYSBzZXNzaW9uLgpUdSB0cm91dmVyYXMgcGx1cyBkZSBkw6l0YWlscyBkYW5zIGxlIHRhYmxlYXUgY2ktZGVzc291cy48L3A+PC9saT4KPGxpPjxoNCBpZD0ianNlY3Rpb253aWRlcnNwcnVjaHN1bmRiZXNlaXRpZ3VuZ3NtZ2xpY2hrZWl0Ij5Qb3NzaWJpbGl0w6kgZGUgZmFpcmUgb3Bwb3NpdGlvbiBldCBkZSBkZW1hbmRlciBsYSBzdXBwcmVzc2lvbjwvaDQ+CjxwPlR1IHBldXggY29uZmlndXJlciB0b24gbmF2aWdhdGV1ciBjb21tZSB0dSBsZSBzb3VoYWl0ZXMgcG91ciBlbXDDqmNoZXIgZGUgbWFuacOocmUgZ8OpbsOpcmFsZSBsJ2luc3RhbGxhdGlvbiBkZSBjb29raWVzLgpUdSBwZXV4IGFsb3JzIGTDqWNpZGVyIGF1IGNhcyBwYXIgY2FzIGQnYWNjZXB0ZXIgb3Ugbm9uIGxlcyBjb29raWVzLCBvdSBiaWVuIGxlcyBhY2NlcHRlciBzeXN0w6ltYXRpcXVlbWVudC4KTGVzIGNvb2tpZXMgcGV1dmVudCDDqnRyZSB1dGlsaXPDqXMgw6AgZGlmZsOpcmVudGVzIGZpbnMsIHBhciBleGVtcGxlIHBvdXIgcmVjb25uYcOudHJlIHF1ZSB0b24gYXBwYXJlaWwgZXN0IGTDqWrDoCBjb25uZWN0w6kgw6Agbm90cmUgc2l0ZSB3ZWIgKGNvb2tpZXMgcGVybWFuZW50cykgb3UgcG91ciBlbnJlZ2lzdHJlciBsZXMgb2ZmcmVzIHF1ZSB0dSBhcyBjb25zdWx0w6llcyBlbiBkZXJuaWVyIChjb29raWVzIGRlIHNlc3Npb24pLgpTaSB0dSBub3VzIGFzIGV4cHJlc3PDqW1lbnQgZG9ubsOpIGwnYXV0b3Jpc2F0aW9uIGRlIHRyYWl0ZXIgdGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsLCB0dSBwZXV4IHJldGlyZXIgY2UgY29uc2VudGVtZW50IMOgIHRvdXQgbW9tZW50LgpOb3RlIGJpZW4gcXVlIGNlbGEgbidhZmZlY3RlIGVuIHJpZW4gbGEgbGljw6lpdMOpIGR1IHRyYWl0ZW1lbnQgZWZmZWN0dcOpIHN1ciBsYSBiYXNlIGRlIHRvbiBjb25zZW50ZW1lbnQganVzcXUnw6Agc2EgcsOpdm9jYXRpb24uPC9wPjwvbGk+CjwvdWw+Cjx0YWJsZT4KPHRoZWFkPgo8dHI+Cjx0aD5Ob20gZHUgY29va2llPC90aD4KPHRoPlNlcnZldXI8L3RoPgo8dGg+Rm91cm5pc3NldXI8L3RoPgo8dGg+RmluYWxpdMOpPC90aD4KPHRoPkJhc2UganVyaWRpcXVlPC90aD4KPHRoPkR1csOpZSBkZSBjb25zZXJ2YXRpb248L3RoPgo8dGg+VHlwZTwvdGg+CjwvdHI+CjwvdGhlYWQ+Cjx0Ym9keT4KPHRyPgo8dGQgZGF0YS1oZWFkZXI9IkNvb2tpZS1OYW1lIj5KT1RGT1JNX1NFU1NJT048L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNlcnZlciI+LmpvdGZvci5tczwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iQW5iaWV0ZXIiPjxhIGhyZWY9IiN0cmFja2VyLTAxMWIyYmFlLTc2MzAtNDc5NS04OWJlLTVhZmFjNzI0MWU4MCI+Sm90Rm9ybTwvYT48L3RkPgo8dGQgZGF0YS1oZWFkZXI9Ilp3ZWNrIj5DZSBjb29raWUgZXN0IGluc3RhbGzDqSBwb3VyIG5vdXMgcGVybWV0dHJlIGRlIHN0b2NrZXIgZGVzIGluZm9ybWF0aW9ucyBzdXIgdG9uIHV0aWxpc2F0aW9uIGR1IHNpdGUuIElsIHNlcnQgbm90YW1tZW50IMOgIGTDqXRlcm1pbmVyIGV0IMOgIGVucmVnaXN0cmVyIHRlcyBwYXJhbcOodHJlcyBwZXJzb25uZWxzLjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iUmVjaHRzZ3J1bmRsYWdlIj5BcnQuIDYsIGFsLiAxLCBsZXQuIGEgZHUgUkdQRCBvdSBhcnQuIDksIGFsLiAyLCBsZXQuIGEgZHUgUkdQRCAoY29uc2VudGVtZW50KTwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iU3BlaWNoZXJkYXVlciI+ZW52aXJvbiAzMCBqb3VyczwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iVHlwIj5Db25maWd1cmF0aW9uPC90ZD4KPC90cj4KPHRyPgo8dGQgZGF0YS1oZWFkZXI9IkNvb2tpZS1OYW1lIj5fX2NmbGI8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNlcnZlciI+YXBpMi5oY2FwdGNoYS5jb208L3RkPgo8dGQgZGF0YS1oZWFkZXI9IkFuYmlldGVyIj48YSBocmVmPSIjdHJhY2tlci0zN2JhNzE4Mi01M2M5LTQ4YjYtYTQ0OS1jNDEzY2I0NTE3MWQiPmhjYXB0Y2hhPC9hPjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iWndlY2siPkNlIGNvb2tpZSBwZXJtZXQgZGUgcydhc3N1cmVyIHF1ZSBjZXJ0YWluZXMgcGFydGllcyBkZSBub3RyZSBzaXRlIHdlYiBzZSBjaGFyZ2VudCB0b3Vqb3VycyBhdXNzaSB2aXRlIGV0IGVmZmljYWNlbWVudCBxdWUgcG9zc2libGUgZ3LDomNlIGF1IENETiBDbG91ZGZsYXJlLiBFbiBwbHVzIGQnYWNjw6lsw6lyZXIgbCdhZmZpY2hhZ2UgZHUgY29udGVudSBkZXMgcGFnZXMsIMOnYSBwZXJtZXQgYXVzc2kgZGUgc2UgcHLDqW11bmlyIGNvbnRyZSBsZXMgYWNjw6hzIGFidXNpZnMgYXUgc2l0ZS48L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlJlY2h0c2dydW5kbGFnZSI+QXJ0LiA2LCBhbC4gMSwgbGV0LiBmIGR1IFJHUEQgKGludMOpcsOqdHMgbMOpZ2l0aW1lcyk8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNwZWljaGVyZGF1ZXIiPmVudmlyb24gMzAgbWludXRlczwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iVHlwIj5Db25maWd1cmF0aW9uPC90ZD4KPC90cj4KPHRyPgo8dGQgZGF0YS1oZWFkZXI9IkNvb2tpZS1OYW1lIj5fX3dwZG1fY2xpZW50PC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJTZXJ2ZXIiPnRpc3NpLmRlPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJBbmJpZXRlciI+PGEgaHJlZj0iI3Jlc3BvbnNpYmxlLWVudGl0eSI+RXhwbG9pdGFudCBkdSBzaXRlPC9hPjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iWndlY2siPkNlIGNvb2tpZSBub3VzIHBlcm1ldCBkJ2VucmVnaXN0cmVyIGNlcnRhaW5zIHBhcmFtw6h0cmVzIGRlIGNvbmZvcnQgcXVlIHR1IGFzIGNob2lzaXMgZXQgZGUgbGVzIGNvbnNlcnZlciBwb3VyIHRhIHZpc2l0ZSBhY3R1ZWxsZSBldCB0ZXMgcHJvY2hhaW5lcyB2aXNpdGVzIHN1ciBsZSBzaXRlLjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iUmVjaHRzZ3J1bmRsYWdlIj5BcnQuIDYsIGFsLiAxLCBsZXQuIGEgZHUgUkdQRCBvdSBhcnQuIDksIGFsLiAyLCBsZXQuIGEgZHUgUkdQRCAoY29uc2VudGVtZW50KTwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iU3BlaWNoZXJkYXVlciI+U2Vzc2lvbjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iVHlwIj5Db25maWd1cmF0aW9uPC90ZD4KPC90cj4KPHRyPgo8dGQgZGF0YS1oZWFkZXI9IkNvb2tpZS1OYW1lIj5fZ2E8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNlcnZlciI+dGlzc2kuZGU8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IkFuYmlldGVyIj48YSBocmVmPSIjdHJhY2tlci00MTgiPkdvb2dsZSBBbmFseXRpY3M8L2E+PC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJad2VjayI+Q2UgY29va2llIGF0dHJpYnVlIHVuIGlkZW50aWZpYW50IMOgIHVuIHV0aWxpc2F0ZXVyIGFmaW4gcXVlIGxlIG91dGlsIGRlIHN1aXZpIHB1aXNzZSByZWdyb3VwZXIgbGVzIGFjdGlvbnMgZGUgbCd1dGlsaXNhdGV1ciBzb3VzIGNldCBpZGVudGlmaWFudC48L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlJlY2h0c2dydW5kbGFnZSI+QXJ0LiA2LCBhbC4gMSwgbGV0LiBhIGR1IFJHUEQgb3UgYXJ0LiA5LCBhbC4gMiwgbGV0LiBhIGR1IFJHUEQgKGNvbnNlbnRlbWVudCk8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNwZWljaGVyZGF1ZXIiPmVudmlyb24gMjQgbW9pczwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iVHlwIj5BbmFseXRpY3M8L3RkPgo8L3RyPgo8dHI+Cjx0ZCBkYXRhLWhlYWRlcj0iQ29va2llLU5hbWUiPl9nYV88L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNlcnZlciI+dGlzc2kuZGU8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IkFuYmlldGVyIj48YSBocmVmPSIjdHJhY2tlci00MTgiPkdvb2dsZSBBbmFseXRpY3M8L2E+PC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJad2VjayI+Q2UgY29va2llIGVucmVnaXN0cmUsIGRhbnMgbGUgY2FkcmUgZGUgR29vZ2xlIEFuYWx5dGljcyBvdSBkZSBHb29nbGUgVGFnIE1hbmFnZXIsIHVuIGlkZW50aWZpYW50IHVuaXF1ZSBwb3VyIGNoYXF1ZSB2aXNpdGV1ciBkdSBzaXRlIHdlYiBldCBzdWl0IGxhIGZhw6dvbiBkb250IGNlIGRlcm5pZXIgdXRpbGlzZSBsZSBzaXRlLjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iUmVjaHRzZ3J1bmRsYWdlIj5BcnQuIDYsIGFsLiAxLCBsZXQuIGEgZHUgUkdQRCBvdSBhcnQuIDksIGFsLiAyLCBsZXQuIGEgZHUgUkdQRCAoY29uc2VudGVtZW50KSAgICA8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNwZWljaGVyZGF1ZXIiPmVudmlyb24gMjQgbW9pczwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iVHlwIj5BbmFseXRpY3M8L3RkPgo8L3RyPgo8dHI+Cjx0ZCBkYXRhLWhlYWRlcj0iQ29va2llLU5hbWUiPl9nY2xfYXU8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNlcnZlciI+dGlzc2kuZGU8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IkFuYmlldGVyIj48YSBocmVmPSIjdHJhY2tlci0xMTIiPkdvb2dsZSBUYWcgTWFuYWdlcjwvYT48L3RkPgo8dGQgZGF0YS1oZWFkZXI9Ilp3ZWNrIj5DZSBjb29raWUgZXN0IHV0aWxpc8OpIHBhciBHb29nbGUgQWRTZW5zZSBwb3VyIGFtw6lsaW9yZXIgbCdlZmZpY2FjaXTDqSBkZSBsYSBwdWJsaWNpdMOpLjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iUmVjaHRzZ3J1bmRsYWdlIj5BcnQuIDYsIGFsLiAxLCBsZXQuIGEgZHUgUkdQRCBvdSBhcnQuIDksIGFsLiAyLCBsZXQuIGEgZHUgUkdQRCAoY29uc2VudGVtZW50KTwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iU3BlaWNoZXJkYXVlciI+ZW52aXJvbiAzIG1vaXM8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlR5cCI+TWFya2V0aW5nPC90ZD4KPC90cj4KPHRyPgo8dGQgZGF0YS1oZWFkZXI9IkNvb2tpZS1OYW1lIj5jb29raWVkaXNhbGxvdzwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iU2VydmVyIj50aXNzaS5kZTwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iQW5iaWV0ZXIiPjxhIGhyZWY9IiNyZXNwb25zaWJsZS1lbnRpdHkiPkV4cGxvaXRhbnQgZHUgc2l0ZTwvYT48L3RkPgo8dGQgZGF0YS1oZWFkZXI9Ilp3ZWNrIj5DZSBjb29raWUgbm91cyBwZXJtZXQgZCdlbnJlZ2lzdHJlciBjZXJ0YWlucyBwYXJhbcOodHJlcyBkZSBjb25mb3J0IHF1ZSB0dSBhcyBjaG9pc2lzIGV0IGRlIGxlcyBjb25zZXJ2ZXIgcG91ciB0YSB2aXNpdGUgYWN0dWVsbGUgZXQgdGVzIHByb2NoYWluZXMgdmlzaXRlcyBzdXIgbGUgc2l0ZS48L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlJlY2h0c2dydW5kbGFnZSI+QXJ0LiA2LCBhbC4gMSwgbGV0LiBhIGR1IFJHUEQgb3UgYXJ0LiA5LCBhbC4gMiwgbGV0LiBhIGR1IFJHUEQgKGNvbnNlbnRlbWVudCk8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNwZWljaGVyZGF1ZXIiPmVudmlyb24gMTIgbW9pczwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iVHlwIj5Db25maWd1cmF0aW9uPC90ZD4KPC90cj4KPHRyPgo8dGQgZGF0YS1oZWFkZXI9IkNvb2tpZS1OYW1lIj5jb29raWVkaXNhbGxvd191cGRhdGVkPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJTZXJ2ZXIiPnRpc3NpLmRlPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJBbmJpZXRlciI+PGEgaHJlZj0iI3Jlc3BvbnNpYmxlLWVudGl0eSI+RXhwbG9pdGFudCBkdSBzaXRlPC9hPjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iWndlY2siPkNlIGNvb2tpZSBub3VzIHBlcm1ldCBkJ2VucmVnaXN0cmVyIGNlcnRhaW5zIHBhcmFtw6h0cmVzIGRlIGNvbmZvcnQgcXVlIHR1IGFzIGNob2lzaXMgZXQgZGUgbGVzIGNvbnNlcnZlciBwb3VyIHRhIHZpc2l0ZSBhY3R1ZWxsZSBldCB0ZXMgcHJvY2hhaW5lcyB2aXNpdGVzIHN1ciBsZSBzaXRlLjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iUmVjaHRzZ3J1bmRsYWdlIj5BcnQuIDYsIGFsLiAxLCBsZXQuIGEgZHUgUkdQRCBvdSBhcnQuIDksIGFsLiAyLCBsZXQuIGEgZHUgUkdQRCAoY29uc2VudGVtZW50KTwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iU3BlaWNoZXJkYXVlciI+ZW52aXJvbiAxMiBtb2lzPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJUeXAiPkNvbmZpZ3VyYXRpb248L3RkPgo8L3RyPgo8dHI+Cjx0ZCBkYXRhLWhlYWRlcj0iQ29va2llLU5hbWUiPmNvb2tpZWRpc2FsbG93X3V1aWQ8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNlcnZlciI+dGlzc2kuZGU8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IkFuYmlldGVyIj48YSBocmVmPSIjcmVzcG9uc2libGUtZW50aXR5Ij5FeHBsb2l0YW50IGR1IHNpdGU8L2E+PC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJad2VjayI+Q2UgY29va2llIG5vdXMgcGVybWV0IGQnZW5yZWdpc3RyZXIgY2VydGFpbnMgcGFyYW3DqHRyZXMgZGUgY29uZm9ydCBxdWUgdHUgYXMgY2hvaXNpcyBldCBkZSBsZXMgY29uc2VydmVyIHBvdXIgdGEgdmlzaXRlIGFjdHVlbGxlIGV0IHRlcyBwcm9jaGFpbmVzIHZpc2l0ZXMgc3VyIGxlIHNpdGUuPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJSZWNodHNncnVuZGxhZ2UiPkFydC4gNiwgYWwuIDEsIGxldC4gYSBkdSBSR1BEIG91IGFydC4gOSwgYWwuIDIsIGxldC4gYSBkdSBSR1BEIChjb25zZW50ZW1lbnQpPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJTcGVpY2hlcmRhdWVyIj5lbnZpcm9uIDEyIG1vaXM8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlR5cCI+Q29uZmlndXJhdGlvbjwvdGQ+CjwvdHI+Cjx0cj4KPHRkIGRhdGEtaGVhZGVyPSJDb29raWUtTmFtZSI+aW52aXTDqTwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iU2VydmVyIj4uam90Zm9yLm1zPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJBbmJpZXRlciI+PGEgaHJlZj0iI3RyYWNrZXItMDExYjJiYWUtNzYzMC00Nzk1LTg5YmUtNWFmYWM3MjQxZTgwIj5Kb3RGb3JtPC9hPjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iWndlY2siPkxlIGNvb2tpZSB1dGlsaXPDqSBhdHRyaWJ1ZSB1biBpZGVudGlmaWFudCBhdSB2aXNpdGV1ciBldCByZWN1ZWlsbGUgZGVzIGRvbm7DqWVzIHN0YXRpc3RpcXVlcyBzdXIgc2VzIHZpc2l0ZXMgc3VyIGxlIHNpdGUuIMOHYSBwZXJtZXQgZGUgcGVyc29ubmFsaXNlciBsZXMgcHVibGljaXTDqXMgcXVpIHMnYWZmaWNoZW50IHBvdXIgbCd1dGlsaXNhdGV1ci48L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlJlY2h0c2dydW5kbGFnZSI+QXJ0LiA2LCBhbC4gMSwgbGV0LiBhIGR1IFJHUEQgb3UgYXJ0LiA5LCBhbC4gMiwgbGV0LiBhIGR1IFJHUEQgKGNvbnNlbnRlbWVudCk8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNwZWljaGVyZGF1ZXIiPmVudmlyb24gMzEgam91cnM8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlR5cCI+TWFya2V0aW5nPC90ZD4KPC90cj4KPHRyPgo8dGQgZGF0YS1oZWFkZXI9IkNvb2tpZS1OYW1lIj5zYmpzX2N1cnJlbnQ8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNlcnZlciI+dGlzc2kuZGUsIC50aXNzaS5kZTwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iQW5iaWV0ZXIiPjxhIGhyZWY9IiNyZXNwb25zaWJsZS1lbnRpdHkiPkV4cGxvaXRhbnQgZHUgc2l0ZSB3ZWI8L2E+PC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJad2VjayI+Q2UgY29va2llIGVzdCBpbnN0YWxsw6kgZGFucyBsZSBjYWRyZSBkdSBwbHVnaW4gV29vQ29tbWVyY2UuIElsIHNlcnQgw6AgaWRlbnRpZmllciBsZSBzaXRlIHdlYiB2aXNpdMOpIHByw6ljw6lkZW1tZW50IGV0IMOgIGVucmVnaXN0cmVyIGRlcyBpbmZvcm1hdGlvbnMgc3VyIGxlcyBhY3Rpb25zIGRlIGwndXRpbGlzYXRldXIuPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJSZWNodHNncnVuZGxhZ2UiPkFydC4gNiwgYWwuIDEsIGxldC4gYSBkdSBSR1BEIG91IGFydC4gOSwgYWwuIDIsIGxldC4gYSBkdSBSR1BEIChjb25zZW50ZW1lbnQpPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJTcGVpY2hlcmRhdWVyIj5TZXNzaW9uPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJUeXAiPkFuYWx5dGljczwvdGQ+CjwvdHI+Cjx0cj4KPHRkIGRhdGEtaGVhZGVyPSJDb29raWUtTmFtZSI+c2Jqc19jdXJyZW50X2FkZDwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iU2VydmVyIj50aXNzaS5kZSwgLnRpc3NpLmRlPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJBbmJpZXRlciI+PGEgaHJlZj0iI3Jlc3BvbnNpYmxlLWVudGl0eSI+RXhwbG9pdGFudCBkdSBzaXRlIHdlYjwvYT48L3RkPgo8dGQgZGF0YS1oZWFkZXI9Ilp3ZWNrIj5DZSBjb29raWUgZXN0IGluc3RhbGzDqSBkYW5zIGxlIGNhZHJlIGR1IHBsdWdpbiBXb29Db21tZXJjZS4gSWwgc2VydCDDoCBpZGVudGlmaWVyIGxlIHNpdGUgd2ViIHZpc2l0w6kgcHLDqWPDqWRlbW1lbnQgZXQgw6AgZW5yZWdpc3RyZXIgZGVzIGluZm9ybWF0aW9ucyBzdXIgbGVzIGFjdGlvbnMgZGUgbCd1dGlsaXNhdGV1ci48L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlJlY2h0c2dydW5kbGFnZSI+QXJ0LiA2LCBhbC4gMSwgbGV0LiBhIGR1IFJHUEQgb3UgYXJ0LiA5LCBhbC4gMiwgbGV0LiBhIGR1IFJHUEQgKGNvbnNlbnRlbWVudCk8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNwZWljaGVyZGF1ZXIiPlNlc3Npb248L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlR5cCI+QW5hbHl0aWNzPC90ZD4KPC90cj4KPHRyPgo8dGQgZGF0YS1oZWFkZXI9IkNvb2tpZS1OYW1lIj5zYmpzX2ZpcnN0PC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJTZXJ2ZXIiPnRpc3NpLmRlLCAudGlzc2kuZGU8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IkFuYmlldGVyIj48YSBocmVmPSIjcmVzcG9uc2libGUtZW50aXR5Ij5FeHBsb2l0YW50IGR1IHNpdGUgd2ViPC9hPjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iWndlY2siPkNlIGNvb2tpZSBlc3QgaW5zdGFsbMOpIGRhbnMgbGUgY2FkcmUgZHUgcGx1Z2luIFdvb0NvbW1lcmNlLiBJbCBzZXJ0IMOgIGlkZW50aWZpZXIgbGUgc2l0ZSB3ZWIgdmlzaXTDqSBwcsOpY8OpZGVtbWVudCBldCDDoCBlbnJlZ2lzdHJlciBkZXMgaW5mb3JtYXRpb25zIHN1ciBsZXMgYWN0aW9ucyBkZSBsJ3V0aWxpc2F0ZXVyLjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iUmVjaHRzZ3J1bmRsYWdlIj5BcnQuIDYsIGFsLiAxLCBsZXQuIGEgZHUgUkdQRCBvdSBhcnQuIDksIGFsLiAyLCBsZXQuIGEgZHUgUkdQRCAoY29uc2VudGVtZW50KTwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iU3BlaWNoZXJkYXVlciI+U2Vzc2lvbjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iVHlwIj5BbmFseXRpY3M8L3RkPgo8L3RyPgo8dHI+Cjx0ZCBkYXRhLWhlYWRlcj0iQ29va2llLU5hbWUiPnNianNfZmlyc3RfYWRkPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJTZXJ2ZXIiPnRpc3NpLmRlLCAudGlzc2kuZGU8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IkFuYmlldGVyIj48YSBocmVmPSIjcmVzcG9uc2libGUtZW50aXR5Ij5FeHBsb2l0YW50IGR1IHNpdGUgd2ViPC9hPjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iWndlY2siPkNlIGNvb2tpZSBlc3QgaW5zdGFsbMOpIGRhbnMgbGUgY2FkcmUgZHUgcGx1Z2luIFdvb0NvbW1lcmNlLiBJbCBzZXJ0IMOgIGlkZW50aWZpZXIgbGUgc2l0ZSB3ZWIgdmlzaXTDqSBwcsOpY8OpZGVtbWVudCBldCDDoCBlbnJlZ2lzdHJlciBkZXMgaW5mb3JtYXRpb25zIHN1ciBsZXMgYWN0aW9ucyBkZSBsJ3V0aWxpc2F0ZXVyLjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iUmVjaHRzZ3J1bmRsYWdlIj5BcnQuIDYsIGFsLiAxLCBsZXQuIGEgZHUgUkdQRCBvdSBhcnQuIDksIGFsLiAyLCBsZXQuIGEgZHUgUkdQRCAoY29uc2VudGVtZW50KTwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iU3BlaWNoZXJkYXVlciI+U2Vzc2lvbjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iVHlwIj5BbmFseXRpY3M8L3RkPgo8L3RyPgo8dHI+Cjx0ZCBkYXRhLWhlYWRlcj0iQ29va2llLU5hbWUiPnNianNfbWlncmF0aW9uczwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iU2VydmVyIj50aXNzaS5kZSwgLnRpc3NpLmRlPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJBbmJpZXRlciI+PGEgaHJlZj0iI3Jlc3BvbnNpYmxlLWVudGl0eSI+RXhwbG9pdGFudCBkdSBzaXRlIHdlYjwvYT48L3RkPgo8dGQgZGF0YS1oZWFkZXI9Ilp3ZWNrIj5DZSBjb29raWUgZXN0IGluc3RhbGzDqSBkYW5zIGxlIGNhZHJlIGR1IHBsdWdpbiBXb29Db21tZXJjZS4gSWwgc2VydCDDoCBpZGVudGlmaWVyIGxlIHNpdGUgd2ViIHZpc2l0w6kgcHLDqWPDqWRlbW1lbnQgZXQgw6AgZW5yZWdpc3RyZXIgZGVzIGluZm9ybWF0aW9ucyBzdXIgbGVzIGFjdGlvbnMgZGUgbCd1dGlsaXNhdGV1ci48L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlJlY2h0c2dydW5kbGFnZSI+QXJ0LiA2LCBhbC4gMSwgbGV0LiBhIGR1IFJHUEQgb3UgYXJ0LiA5LCBhbC4gMiwgbGV0LiBhIGR1IFJHUEQgKGNvbnNlbnRlbWVudCk8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNwZWljaGVyZGF1ZXIiPlNlc3Npb248L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlR5cCI+QW5hbHl0aWNzPC90ZD4KPC90cj4KPHRyPgo8dGQgZGF0YS1oZWFkZXI9IkNvb2tpZS1OYW1lIj5zYmpzX3Nlc3Npb248L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNlcnZlciI+dGlzc2kuZGUsIC50aXNzaS5kZTwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iQW5iaWV0ZXIiPjxhIGhyZWY9IiNyZXNwb25zaWJsZS1lbnRpdHkiPsOJZGl0ZXVyIGR1IHNpdGU8L2E+PC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJad2VjayI+Q2UgY29va2llIGVzdCBpbnN0YWxsw6kgZGFucyBsZSBjYWRyZSBkdSBwbHVnaW4gV29vQ29tbWVyY2UuIElsIHNlcnQgw6AgaWRlbnRpZmllciBsZSBzaXRlIHdlYiB2aXNpdMOpIHByw6ljw6lkZW1tZW50IGV0IMOgIGVucmVnaXN0cmVyIGRlcyBpbmZvcm1hdGlvbnMgc3VyIGxlcyBhY3Rpb25zIGRlIGwndXRpbGlzYXRldXIuPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJSZWNodHNncnVuZGxhZ2UiPkFydC4gNiwgYWwuIDEsIGxldC4gYSBkdSBSR1BEIG91IGFydC4gOSwgYWwuIDIsIGxldC4gYSBkdSBSR1BEIChjb25zZW50ZW1lbnQpPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJTcGVpY2hlcmRhdWVyIj5lbnZpcm9uIDMxIG1pbnV0ZXM8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlR5cCI+QW5hbHl0aWNzPC90ZD4KPC90cj4KPHRyPgo8dGQgZGF0YS1oZWFkZXI9IkNvb2tpZS1OYW1lIj5zYmpzX3VkYXRhPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJTZXJ2ZXIiPnRpc3NpLmRlLCAudGlzc2kuZGU8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IkFuYmlldGVyIj48YSBocmVmPSIjcmVzcG9uc2libGUtZW50aXR5Ij5FeHBsb2l0YW50IGR1IHNpdGUgd2ViPC9hPjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iWndlY2siPkNlIGNvb2tpZSBlc3QgaW5zdGFsbMOpIGRhbnMgbGUgY2FkcmUgZHUgcGx1Z2luIFdvb0NvbW1lcmNlLiBJbCBzZXJ0IMOgIGlkZW50aWZpZXIgbGUgc2l0ZSB3ZWIgdmlzaXTDqSBwcsOpY8OpZGVtbWVudCBldCDDoCBlbnJlZ2lzdHJlciBkZXMgaW5mb3JtYXRpb25zIHN1ciBsZXMgYWN0aW9ucyBkZSBsJ3V0aWxpc2F0ZXVyLjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iUmVjaHRzZ3J1bmRsYWdlIj5BcnQuIDYsIGFsLiAxLCBsZXQuIGEgZHUgUkdQRCBvdSBhcnQuIDksIGFsLiAyLCBsZXQuIGEgZHUgUkdQRCAoY29uc2VudGVtZW50KTwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iU3BlaWNoZXJkYXVlciI+U2Vzc2lvbjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iVHlwIj5BbmFseXRpY3M8L3RkPgo8L3RyPgo8dHI+Cjx0ZCBkYXRhLWhlYWRlcj0iQ29va2llLU5hbWUiPnRlc3RfY29va2llPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJTZXJ2ZXIiPi5kb3VibGVjbGljay5uZXQ8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IkFuYmlldGVyIj48YSBocmVmPSIjcmVzcG9uc2libGUtZW50aXR5Ij5FeHBsb2l0YW50IGR1IHNpdGUgd2ViPC9hPjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iWndlY2siPkNlIGNvb2tpZSBlc3QgaW5zdGFsbMOpIHBvdXIgdsOpcmlmaWVyIHNpIGxlIG5hdmlnYXRldXIgZHUgdmlzaXRldXIgZHUgc2l0ZSBwcmVuZCBlbiBjaGFyZ2UgbGVzIGNvb2tpZXMgcG91ciBsZSBzZXJ2aWNlIERvdWJsZUNsaWNrLjwvdGQ+Cjx0ZCBkYXRhLWhlYWRlcj0iUmVjaHRzZ3J1bmRsYWdlIj5BcnQuIDYsIGFsLiAxLCBsZXQuIGMgZHUgUkdQRCAocmVzcGVjdCBkJ3VuZSBvYmxpZ2F0aW9uIGzDqWdhbGUpPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJTcGVpY2hlcmRhdWVyIj5lbnZpcm9uIDE2IG1pbnV0ZXM8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlR5cCI+QmFubmnDqHJlIGRlIGNvb2tpZXM8L3RkPgo8L3RyPgo8dHI+Cjx0ZCBkYXRhLWhlYWRlcj0iQ29va2llLU5hbWUiPnVzZXJSZWZlcmVyPC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJTZXJ2ZXIiPi5qb3Rmb3IubXM8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IkFuYmlldGVyIj48YSBocmVmPSIjdHJhY2tlci0wMTFiMmJhZS03NjMwLTQ3OTUtODliZS01YWZhYzcyNDFlODAiPkpvdEZvcm08L2E+PC90ZD4KPHRkIGRhdGEtaGVhZGVyPSJad2VjayI+Q2UgY29va2llIGVzdCBpbnN0YWxsw6kgcG91ciBub3VzIHBlcm1ldHRyZSBkZSBzdG9ja2VyIGRlcyBpbmZvcm1hdGlvbnMgc3VyIHRvbiB1dGlsaXNhdGlvbiBkdSBzaXRlLiBJbCBzZXJ0IG5vdGFtbWVudCDDoCBkw6l0ZXJtaW5lciBldCDDoCBlbnJlZ2lzdHJlciB0ZXMgcGFyYW3DqHRyZXMgcGVyc29ubmVscy48L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlJlY2h0c2dydW5kbGFnZSI+QXJ0LiA2LCBhbC4gMSwgbGV0LiBhIGR1IFJHUEQgb3UgYXJ0LiA5LCBhbC4gMiwgbGV0LiBhIGR1IFJHUEQgKGNvbnNlbnRlbWVudCk8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlNwZWljaGVyZGF1ZXIiPmVudmlyb24gMzEgam91cnM8L3RkPgo8dGQgZGF0YS1oZWFkZXI9IlR5cCI+Q29uZmlndXJhdGlvbjwvdGQ+CjwvdHI+CjwvdGJvZHk+CjwvdGFibGU+CjxwIGlkPSJqc2VjdGlvbmNvb2tpZWJhbm5lcmNvbmZpZyIgc3R5bGU9ImRpc3BsYXk6IG5vbmU7Ij4KU2kgZGVzIGNvb2tpZXMgb250IMOpdMOpIGluc3RhbGzDqXMgc3VyIGxhIGJhc2UgZGUgdG9uIGNvbnNlbnRlbWVudCwgdHUgcGV1eCByZXRpcmVyIHRvbiBjb25zZW50ZW1lbnQgw6AgdG91dCBtb21lbnQgZGFucyBsZXMgcGFyYW3DqHRyZXMgZGVzIGNvb2tpZXMgZGUgbGEgYmFubmnDqHJlIGTDqWRpw6llLgpUdSBwZXV4IG1vZGlmaWVyIGxlcyBwYXJhbcOodHJlcyBkZXMgY29va2llcyA8YSBocmVmPSJqYXZhc2NyaXB0OndpbmRvdy5kb2N1bWVudC5jb29raWVCYW5uZXIuc2hvdygpIiBjbGFzcz0iam1kQ29va2llQ29uc2VudEluamVjdFNob3ciPmljaTwvYT4uCjwvcD48L2Rpdj4KPGgyIGlkPSJqc2VjdGlvbmRhdGVuc2ljaGVyaGVpdHVuZGRhdGVuc2NodXR6a29tbXVuaWthdGlvbnBlcmVtYWlsIj5Tw6ljdXJpdMOpIGV0IGNvbmZpZGVudGlhbGl0w6kgZGVzIGRvbm7DqWVzLCBjb21tdW5pY2F0aW9uIHBhciBlLW1haWw8L2gyPgo8cD5UZXMgZG9ubsOpZXMgcGVyc29ubmVsbGVzIHNvbnQgcHJvdMOpZ8OpZXMgcGFyIGRlcyBtZXN1cmVzIHRlY2huaXF1ZXMgZXQgb3JnYW5pc2F0aW9ubmVsbGVzIGxvcnMgZGUgbGV1ciBjb2xsZWN0ZSwgZGUgbGV1ciBzdG9ja2FnZSBldCBkZSBsZXVyIHRyYWl0ZW1lbnQsIGRlIG1hbmnDqHJlIMOgIGNlIHF1J2VsbGVzIG5lIHNvaWVudCBwYXMgYWNjZXNzaWJsZXMgw6AgZGVzIHRpZXJzLgpFbiBjYXMgZGUgY29tbXVuaWNhdGlvbiBwYXIgZS1tYWlsIG5vbiBjcnlwdMOpZSwgb24gbmUgcGV1dCBwYXMgZ2FyYW50aXIgbGEgc8OpY3VyaXTDqSB0b3RhbGUgZGVzIGRvbm7DqWVzIHBlbmRhbnQgbGV1ciB0cmFuc2ZlcnQgdmVycyBub3Mgc3lzdMOobWVzIGluZm9ybWF0aXF1ZXMgOyBjJ2VzdCBwb3VycXVvaSwgcG91ciBsZXMgaW5mb3JtYXRpb25zIG7DqWNlc3NpdGFudCB1biBoYXV0IG5pdmVhdSBkZSBjb25maWRlbnRpYWxpdMOpLCBvbiByZWNvbW1hbmRlIGQndXRpbGlzZXIgdW5lIGNvbW11bmljYXRpb24gY3J5cHTDqWUgb3UgZCdlbnZveWVyIHVuIGNvdXJyaWVyIHBvc3RhbC48L3A+CjxoMiBpZD0ianNlY3Rpb25hdXRvbWF0aXNjaGVlbWFpbGFyY2hpdmllcnVuZyI+QXJjaGl2YWdlIGF1dG9tYXRpcXVlIGRlcyBlLW1haWxzPC9oMj4KPHVsPgo8bGk+PGg0IGlkPSJqc2VjdGlvbnVtZmFuZ2RlcnZlcmFyYmVpdHVuZ3BlcnNvbmVuYmV6b2dlbmVyZGF0ZW4iPlBvcnTDqWUgZHUgdHJhaXRlbWVudCBkZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWw8L2g0Pgo8cD5PbiB0aWVudCDDoCB0ZSBzaWduYWxlciBleHByZXNzw6ltZW50IHF1ZSBub3RyZSBzeXN0w6htZSBkZSBtZXNzYWdlcmllIGRpc3Bvc2UgZCd1biBwcm9jZXNzdXMgZCdhcmNoaXZhZ2UgYXV0b21hdGlzw6kuClRvdXMgbGVzIGUtbWFpbHMgZW50cmFudHMgZXQgc29ydGFudHMgc29udCBhaW5zaSBhcmNoaXbDqXMgbnVtw6lyaXF1ZW1lbnQgZGUgbWFuacOocmUgY29uZm9ybWUgYXV4IGV4aWdlbmNlcyBkJ2F1ZGl0LjwvcD48L2xpPgo8bGk+PGg0IGlkPSJqc2VjdGlvbnJlY2h0c2dydW5kbGFnZWZyZGlldmVyYXJiZWl0dW5ncGVyc29uZW5iZXpvZ2VuZXJkYXRlbi02Ij5CYXNlIGp1cmlkaXF1ZSBkdSB0cmFpdGVtZW50IGRlcyBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbDwvaDQ+CjxwPkFydC4gNiwgYWwuIDEsIGxldC4gYyBkdSBSR1BEIChvYmxpZ2F0aW9uIGzDqWdhbGUpLgpDZXR0ZSBvYmxpZ2F0aW9uIGzDqWdhbGUgY29uc2lzdGUgw6AgcmVzcGVjdGVyIGxlcyBkaXNwb3NpdGlvbnMgZHUgZHJvaXQgZmlzY2FsIGV0IGR1IGRyb2l0IGNvbW1lcmNpYWwgKHBhciBleGVtcGxlLCBsZXMgYXJ0aWNsZXMgMTQ2IGV0IDE0NyBkdSBDb2RlIGfDqW7DqXJhbCBkZXMgaW1ww7R0cyBhbGxlbWFuZCAoQU8pIGV0IGxlcyBhcnRpY2xlcyAyMzggZXQgMjU3IGR1IENvZGUgZGUgY29tbWVyY2UgYWxsZW1hbmQgKEhHQikpLjwvcD48L2xpPgo8bGk+PGg0IGlkPSJqc2VjdGlvbnp3ZWNrZGVyZGF0ZW52ZXJhcmJlaXR1bmctNiI+RmluYWxpdMOpIGR1IHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzPC9oND4KPHA+TCdhcmNoaXZhZ2UgYSBwb3VyIGJ1dCBkZSByZXNwZWN0ZXIgbGVzIGRpc3Bvc2l0aW9ucyBkdSBkcm9pdCBmaXNjYWwgKHBhciBleGVtcGxlLCBsZXMgYXJ0aWNsZXMgMTQ2LCAxNDcgQU8g4oCTIG9ibGlnYXRpb24gZGUgY29uc2VydmVyIGxlcyBlLW1haWxzIHByw6lzZW50YW50IHVuIGludMOpcsOqdCBmaXNjYWwpIGV0IGR1IGRyb2l0IGNvbW1lcmNpYWwgKHBhciBleGVtcGxlLCBsZXMgYXJ0aWNsZXMgMjM4IGV0IDI1NyBkdSBIR0Ig4oCTIG9ibGlnYXRpb24gZOKAmWFyY2hpdmVyIGxhIGNvcnJlc3BvbmRhbmNlIGNvbW1lcmNpYWxlKS48L3A+PC9saT4KPGxpPjxoNCBpZD0ianNlY3Rpb25kYXVlcmRlcnNwZWljaGVydW5nLTYiPkR1csOpZSBkZSBjb25zZXJ2YXRpb248L2g0Pgo8cD5Ob3Mgw6ljaGFuZ2VzIHBhciBlLW1haWwgc29udCBjb25zZXJ2w6lzIGp1c3F1J8OgIGwnZXhwaXJhdGlvbiBkZXMgb2JsaWdhdGlvbnMgZGUgY29uc2VydmF0aW9uIHByw6l2dWVzIHBhciBsZSBkcm9pdCBmaXNjYWwgZXQgbGUgZHJvaXQgY29tbWVyY2lhbC4KTGEgZHVyw6llIGRlIGNvbnNlcnZhdGlvbiBwZXV0IGFsbGVyIGp1c3F1J8OgIDEwIGFucy48L3A+PC9saT4KPGxpPjxoNCBpZD0ianNlY3Rpb253aWRlcnNwcnVjaHN1bmRsc2NodW5nc21nbGljaGtlaXQtNSI+RHJvaXQgZCdvcHBvc2l0aW9uIGV0IGRlIHN1cHByZXNzaW9uPC9oND4KPHA+VHUgcGV1eCDDoCB0b3V0IG1vbWVudCB0J29wcG9zZXIgYXUgdHJhaXRlbWVudCBkZSB0ZXMgZG9ubsOpZXMgY29uZm9ybcOpbWVudCDDoCBsJ2FydGljbGUgMjEgZHUgUkdQRCBldCBkZW1hbmRlciBsZXVyIGVmZmFjZW1lbnQgY29uZm9ybcOpbWVudCDDoCBsJ2FydGljbGUgMTcgZHUgUkdQRC4KVHUgdHJvdXZlcmFzIGVuIGJhcyBkZSBjZXR0ZSBwb2xpdGlxdWUgZGUgY29uZmlkZW50aWFsaXTDqSBsYSBsaXN0ZSBkZSB0ZXMgZHJvaXRzIGV0IGxhIG1hcmNoZSDDoCBzdWl2cmUgcG91ciBsZXMgZmFpcmUgdmFsb2lyLjwvcD48L2xpPgo8bGk+PGg0IGlkPSJqc2VjdGlvbnVtZ2FuZ21pdGJld2VyYnVuZ3N1bnRlcmxhZ2VuIj5UcmFpdGVtZW50IGRlcyBkb3NzaWVycyBkZSBjYW5kaWRhdHVyZTwvaDQ+CjxwPk9uIHRpZW50IGF1c3NpIMOgIHByw6ljaXNlciBxdSdvbiBuZSBwcmVuZCBlbiBjb21wdGUgcXVlIGxlcyBkb3NzaWVycyBkZSBjYW5kaWRhdHVyZSBhdSBmb3JtYXQgUERGLgpMZXMgZmljaGllcnMgY29tcHJlc3PDqXMgKFdpblppcCwgV2luUkFSLCA3WmlwLCBldGMuKSBzb250IGZpbHRyw6lzIHBhciBub3Mgc3lzdMOobWVzIGRlIHPDqWN1cml0w6kgZXQgbmUgbm91cyBwYXJ2aWVubmVudCBwYXMuCk9uIG5lIHByZW5kIHBhcyBlbiBjb21wdGUgbGVzIGNhbmRpZGF0dXJlcyBhdSBmb3JtYXQgV29yZCBvdSBkYW5zIGTigJlhdXRyZXMgZm9ybWF0cyBkZSBmaWNoaWVycywgZXQgb24gbGVzIHN1cHByaW1lIHNhbnMgbGVzIGxpcmUuCk5vdGUgYmllbiBxdWUgbGVzIGRvc3NpZXJzIGRlIGNhbmRpZGF0dXJlIGVudm95w6lzIHBhciBlLW1haWwgc2FucyDDqnRyZSBjcnlwdMOpcyBwZXV2ZW50LCBsZSBjYXMgw6ljaMOpYW50LCDDqnRyZSBvdXZlcnRzIHBhciBkZXMgdGllcnMgYXZhbnQgZOKAmWFycml2ZXIgZGFucyBub3Mgc3lzdMOobWVzIGluZm9ybWF0aXF1ZXMuCk9uIHBhcnQgZHUgcHJpbmNpcGUgcXUnb24gcGV1dCByw6lwb25kcmUgYXV4IGUtbWFpbHMgZGUgY2FuZGlkYXR1cmUgbm9uIGNyeXB0w6lzIHNhbnMgbGVzIGNyeXB0ZXIgbm9uIHBsdXMuClNpIHR1IG5lIGxlIHNvdWhhaXRlcyBwYXMsIG1lcmNpIGRlIG5vdXMgbGUgc2lnbmFsZXIgZGFucyB0b24gZS1tYWlsIGRlIGNhbmRpZGF0dXJlLjwvcD48L2xpPgo8L3VsPgo8aDIgaWQ9ImpzZWN0aW9uYXVza3VuZnRzYW5zcHJ1Y2h1bmRiZXJpY2h0aWd1bmdzd25zY2hlbHNjaHVuZ2VpbnNjaHJua3VuZ3ZvbmRhdGVud2lkZXJydWZ2b25laW53aWxsaWd1bmdlbndpZGVyc3BydWNoc3JlY2h0Ij5Ecm9pdCBkJ2FjY8OocyBldCBkZW1hbmRlcyBkZSByZWN0aWZpY2F0aW9uIOKAkyBTdXBwcmVzc2lvbiBldCBsaW1pdGF0aW9uIGR1IHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzIOKAkyBSZXRyYWl0IGRlcyBjb25zZW50ZW1lbnRzIOKAkyBEcm9pdCBkJ29wcG9zaXRpb248L2gyPgo8aDMgaWQ9ImpzZWN0aW9uYXVza3VuZnRzYW5zcHJ1Y2giPkRyb2l0IGQnYWNjw6hzIGF1eCBpbmZvcm1hdGlvbnM8L2gzPgo8cD5UdSBhcyBsZSBkcm9pdCBkZSBkZW1hbmRlciB1bmUgY29uZmlybWF0aW9uIGluZGlxdWFudCBzaSBvbiB0cmFpdGUgZGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIHRlIGNvbmNlcm5hbnQuClNpIGMnZXN0IGxlIGNhcywgdHUgYXMgbGUgZHJvaXQgZCdhY2PDqWRlciBhdXggaW5mb3JtYXRpb25zIG1lbnRpb25uw6llcyDDoCBsJ2FydGljbGUgMTUsIHBhcmFncmFwaGUgMSwgZHUgUkdQRCwgcG91ciBhdXRhbnQgcXVlIGNlbGEgbmUgcG9ydGUgcGFzIGF0dGVpbnRlIGF1eCBkcm9pdHMgZXQgbGliZXJ0w6lzIGQnYXV0cnVpIChjZi4gYXJ0aWNsZSAxNSwgcGFyYWdyYXBoZSA0LCBkdSBSR1BEKS4gCk9uIHNlIGZlcmEgdW4gcGxhaXNpciBkZSB0ZSBmb3VybmlyIHVuZSBjb3BpZSBkZSBjZXMgZG9ubsOpZXMuPC9wPgo8aDMgaWQ9ImpzZWN0aW9uYmVyaWNodGlndW5nc2Fuc3BydWNoIj5Ecm9pdCBkZSByZWN0aWZpY2F0aW9uPC9oMz4KPHA+Q29uZm9ybcOpbWVudCDDoCBsJ2FydGljbGUgMTYgZHUgUkdQRCwgdHUgYXMgbGUgZHJvaXQgZGUgbm91cyBkZW1hbmRlciDDoCB0b3V0IG1vbWVudCBkZSBjb3JyaWdlciBsZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgcXVpIGF1cmFpZW50IMOpdMOpIGVucmVnaXN0csOpZXMgZGUgbWFuacOocmUgZXJyb27DqWUgKGNvbW1lIHBhciBleGVtcGxlIHRvbiBhZHJlc3NlLCB0b24gbm9tLCBldGMuKS4KVHUgcGV1eCDDqWdhbGVtZW50IGRlbWFuZGVyIMOgIHRvdXQgbW9tZW50IHF1ZSBsZXMgZG9ubsOpZXMgcXVlIG5vdXMgYXZvbnMgZW5yZWdpc3Ryw6llcyBzb2llbnQgY29tcGzDqXTDqWVzLgpMYSBtb2RpZmljYXRpb24gY29ycmVzcG9uZGFudGUgc2VyYSBlZmZlY3R1w6llIHNhbnMgZMOpbGFpLiA8L3A+CjxoMyBpZD0ianNlY3Rpb25yZWNodGF1ZmxzY2h1bmciPkRyb2l0IMOgIGwnZWZmYWNlbWVudDwvaDM+CjxwPkNvbmZvcm3DqW1lbnQgw6AgbCdhcnRpY2xlIDE3LCBwYXJhZ3JhcGhlIDEsIGR1IFJHUEQsIHR1IGFzIGxlIGRyb2l0IGRlIG5vdXMgZGVtYW5kZXIgZCdlZmZhY2VyIGxlcyBkb25uw6llcyDDoCBjYXJhY3TDqHJlIHBlcnNvbm5lbCBxdWUgbm91cyBhdm9ucyBjb2xsZWN0w6llcyDDoCB0b24gc3VqZXQgc2kgICA8L3A+Cjx1bD4KPGxpPnNvaXQgbGVzIGRvbm7DqWVzIG5lIHNvbnQgcGx1cyBuw6ljZXNzYWlyZXMgOzwvbGk+CjxsaT5sYSBiYXNlIGp1cmlkaXF1ZSBkdSB0cmFpdGVtZW50IGEgZGlzcGFydSBzYW5zIMOqdHJlIHJlbXBsYWPDqWUgc3VpdGUgYXUgcmV0cmFpdCBkZSB0b24gY29uc2VudGVtZW50IDs8L2xpPgo8bGk+dHUgdCdlcyBvcHBvc8OpIGF1IHRyYWl0ZW1lbnQgZXQgcXUnaWwgbidleGlzdGUgYXVjdW4gbW90aWYgbMOpZ2l0aW1lIGp1c3RpZmlhbnQgY2UgdHJhaXRlbWVudCA7PC9saT4KPGxpPnRlcyBkb25uw6llcyBzb250IHRyYWl0w6llcyBkZSBtYW5pw6hyZSBpbGxpY2l0ZSA7PC9saT4KPGxpPnVuZSBvYmxpZ2F0aW9uIGzDqWdhbGUgbCdleGlnZSBvdSB1bmUgY29sbGVjdGUgYSBldSBsaWV1IGNvbmZvcm3DqW1lbnQgw6AgbCdhcnRpY2xlIDgsIHBhcmFncmFwaGUgMSwgZHUgUkdQRC48L2xpPgo8L3VsPgo8cD5Db25mb3Jtw6ltZW50IMOgIGwnYXJ0aWNsZSAxNywgcGFyYWdyYXBoZSAzLCBkdSBSR1BELCBjZSBkcm9pdCBuZSBzJ2FwcGxpcXVlIHBhcyBsb3JzcXVlICA8L3A+Cjx1bD4KPGxpPmxlIHRyYWl0ZW1lbnQgZXN0IG7DqWNlc3NhaXJlIMOgIGwnZXhlcmNpY2UgZHUgZHJvaXQgw6AgbGEgbGliZXJ0w6kgZCdleHByZXNzaW9uIGV0IGQnaW5mb3JtYXRpb24gOzwvbGk+CjxsaT50ZXMgZG9ubsOpZXMgb250IMOpdMOpIGNvbGxlY3TDqWVzIGVuIHZlcnR1IGQndW5lIG9ibGlnYXRpb24gbMOpZ2FsZSA7PC9saT4KPGxpPmxlIHRyYWl0ZW1lbnQgZXN0IG7DqWNlc3NhaXJlIHBvdXIgZGVzIHJhaXNvbnMgZCdpbnTDqXLDqnQgcHVibGljIDs8L2xpPgo8bGk+bGVzIGRvbm7DqWVzIHNvbnQgbsOpY2Vzc2FpcmVzIHBvdXIgZmFpcmUgdmFsb2lyLCBleGVyY2VyIG91IGTDqWZlbmRyZSBkZXMgZHJvaXRzLjwvbGk+CjwvdWw+CjxoMyBpZD0ianNlY3Rpb25yZWNodGF1ZmVpbnNjaHJua3VuZ2RlcnZlcmFyYmVpdHVuZyI+RHJvaXQgw6AgbGEgbGltaXRhdGlvbiBkdSB0cmFpdGVtZW50PC9oMz4KPHA+Q29uZm9ybcOpbWVudCDDoCBsJ2FydGljbGUgMTgsIHBhcmFncmFwaGUgMSwgZHUgUkdQRCwgdHUgYXMgbGUgZHJvaXQsIGRhbnMgY2VydGFpbnMgY2FzLCBkZSBkZW1hbmRlciBsYSBsaW1pdGF0aW9uIGR1IHRyYWl0ZW1lbnQgZGUgdGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsLiAgPC9wPgo8cD5DJ2VzdCBsZSBjYXMgcXVhbmQ8L3A+Cjx1bD4KPGxpPnR1IGNvbnRlc3RlIGwnZXhhY3RpdHVkZSBkZSB0ZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgOzwvbGk+CjxsaT5sZSB0cmFpdGVtZW50IGVzdCBpbGxpY2l0ZSBldCBxdWUgdHUgbmUgY29uc2VucyBwYXMgw6AgbGV1ciBlZmZhY2VtZW50IDs8L2xpPgo8bGk+bGVzIGRvbm7DqWVzIG5lIHNvbnQgcGx1cyBuw6ljZXNzYWlyZXMgYXV4IGZpbnMgZHUgdHJhaXRlbWVudCwgbWFpcyBlbGxlcyBzZXJ2ZW50IMOgIGZhaXJlIHZhbG9pciwgZXhlcmNlciBvdSBkw6lmZW5kcmUgZGVzIGRyb2l0cyA7PC9saT4KPGxpPnVuZSBvcHBvc2l0aW9uIGF1IHRyYWl0ZW1lbnQgYSDDqXTDqSBmb3JtdWzDqWUgY29uZm9ybcOpbWVudCDDoCBsJ2FydGljbGUgMjEsIHBhcmFncmFwaGUgMSwgZHUgUkdQRCBldCBxdSdpbCBuJ2VzdCBwYXMgZW5jb3JlIGNsYWlyIHF1ZWxzIGludMOpcsOqdHMgcHLDqXZhbGVudC48L2xpPgo8L3VsPgo8aDMgaWQ9ImpzZWN0aW9ucmVjaHRhdWZ3aWRlcnJ1ZiI+RHJvaXQgZGUgcsOpdHJhY3RhdGlvbjwvaDM+CjxwPlNpIHR1IG5vdXMgYXMgZG9ubsOpIHRvbiBjb25zZW50ZW1lbnQgZXhwbGljaXRlIHBvdXIgbGUgdHJhaXRlbWVudCBkZSB0ZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgKGFydC4gNiwgYWwuIDEsIGxldC4gYSBkdSBSR1BEIG91IGFydC4gOSwgYWwuIDIsIGxldC4gYSBkdSBSR1BEKSwgdHUgcGV1eCBsZSByZXRpcmVyIMOgIHRvdXQgbW9tZW50LgpOb3RlIGJpZW4gcXVlIGNlbGEgbidhZmZlY3RlIGVuIHJpZW4gbGEgbGljw6lpdMOpIGR1IHRyYWl0ZW1lbnQgZWZmZWN0dcOpIHN1ciBsYSBiYXNlIGRlIHRvbiBjb25zZW50ZW1lbnQganVzcXUnw6Agc2EgcsOpdm9jYXRpb24uPC9wPgo8aDMgaWQ9ImpzZWN0aW9ucmVjaHRhdWZ3aWRlcnNwcnVjaCI+RHJvaXQgZCdvcHBvc2l0aW9uPC9oMz4KPHA+Q29uZm9ybcOpbWVudCDDoCBsJ2FydGljbGUgMjEgZHUgUkdQRCwgdHUgYXMgbGUgZHJvaXQgZGUgdCdvcHBvc2VyIMOgIHRvdXQgbW9tZW50IGF1IHRyYWl0ZW1lbnQgZGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIHRlIGNvbmNlcm5hbnQgcXVpIG9udCDDqXTDqSBjb2xsZWN0w6llcyBlbiB2ZXJ0dSBkZSBsJ2FydGljbGUgNiwgcGFyYWdyYXBoZSAxLCBwb2ludCBmKSAoZGFucyBsZSBjYWRyZSBkJ3VuIGludMOpcsOqdCBsw6lnaXRpbWUpLgpUdSBuZSBwZXV4IGV4ZXJjZXIgY2UgZHJvaXQgcXVlIHMnaWwgZXhpc3RlIGRlcyBjaXJjb25zdGFuY2VzIHBhcnRpY3VsacOocmVzIHMnb3Bwb3NhbnQgw6AgbGEgY29uc2VydmF0aW9uIGV0IGF1IHRyYWl0ZW1lbnQgZGUgY2VzIGRvbm7DqWVzLiAgIDwvcD4KPGgzIGlkPSJqc2VjdGlvbndpZW5laG1lbnNpZWlocmVyZWNodGV3YWhyIj5Db21tZW50IGZhaXMtdHUgdmFsb2lyIHRlcyBkcm9pdHMgPzwvaDM+CjxwPlR1IHBldXggZXhlcmNlciB0ZXMgZHJvaXRzIMOgIHRvdXQgbW9tZW50IGVuIG5vdXMgY29udGFjdGFudCBhdXggY29vcmRvbm7DqWVzIGNpLWRlc3NvdXMgOjwvcD4KPHA+TS5KLiBPc3RlciBHbWJICgpDYWxtb25zdHJhw59lIDgKCjU2ODE0IEJyZW1tCgpBbGxlbWFnbmUKCkUtbWFpbCA6IDxhIGhyZWY9Im1haWx0bzppbmZvQHRpc3NpLmRlIiByZWw9Im5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5pbmZvQHRpc3NpLmRlPC9hPgoKVMOpbC4gOiAwMjY3NTkxMTQ0MAoKRmF4IDogMDI2NzU5MTE0NDE1ICA8L3A+CjxoMiBpZD0ianNlY3Rpb25yZWNodGF1ZmRhdGVuYmVydHJhZ2JhcmtlaXQiPkRyb2l0IMOgIGxhIHBvcnRhYmlsaXTDqSBkZXMgZG9ubsOpZXM8L2gyPgo8cD5Db25mb3Jtw6ltZW50IMOgIGwnYXJ0aWNsZSAyMCBkdSBSR1BELCB0dSBhcyBsZSBkcm9pdCBkZSBkZW1hbmRlciBsYSB0cmFuc21pc3Npb24gZGVzIGRvbm7DqWVzIMOgIGNhcmFjdMOocmUgcGVyc29ubmVsIHRlIGNvbmNlcm5hbnQuCk5vdXMgdGUgZm91cm5pcm9ucyBjZXMgZG9ubsOpZXMgZGFucyB1biBmb3JtYXQgc3RydWN0dXLDqSwgY291cmFtbWVudCB1dGlsaXPDqSBldCBsaXNpYmxlIHBhciBtYWNoaW5lLgpMZXMgZG9ubsOpZXMgcGV1dmVudCDDqnRyZSB0cmFuc21pc2VzIHNvaXQgw6AgdG9pLW3Dqm1lLCBzb2l0IMOgIHVuIHJlc3BvbnNhYmxlIHF1ZSB0dSBhdXJhcyBkw6lzaWduw6kuIDwvcD4KPHA+Q29uZm9ybcOpbWVudCDDoCBsJ2FydGljbGUgMjAsIHBhcmFncmFwaGUgMSwgZHUgUkdQRCwgb24gdGUgZm91cm5pdCBsZXMgZG9ubsOpZXMgc3VpdmFudGVzIHN1ciBzaW1wbGUgZGVtYW5kZSA6ICA8L3A+Cjx1bD4KPGxpPmxlcyBkb25uw6llcyBjb2xsZWN0w6llcyBzdXIgbGEgYmFzZSBkJ3VuIGNvbnNlbnRlbWVudCBleHBsaWNpdGUgY29uZm9ybcOpbWVudCDDoCBsJ2FydGljbGUgNiwgcGFyYWdyYXBoZSAxLCBwb2ludCBhKSBkdSBSR1BEIG91IMOgIGwnYXJ0aWNsZSA5LCBwYXJhZ3JhcGhlIDIsIHBvaW50IGEpIGR1IFJHUEQgOzwvbGk+CjxsaT5sZXMgZG9ubsOpZXMgcXVlIG5vdXMgYXZvbnMgcmXDp3VlcyBkZSB0YSBwYXJ0IGNvbmZvcm3DqW1lbnQgw6AgbCdhcnRpY2xlIDYsIHBhcmFncmFwaGUgMSwgcG9pbnQgYikgZHUgUkdQRCBkYW5zIGxlIGNhZHJlIGRlIGNvbnRyYXRzIGV4aXN0YW50cyA7PC9saT4KPGxpPmxlcyBkb25uw6llcyBxdWkgb250IMOpdMOpIHRyYWl0w6llcyBkYW5zIGxlIGNhZHJlIGQndW4gcHJvY2Vzc3VzIGF1dG9tYXRpc8OpLjwvbGk+CjwvdWw+CjxwPk9uIHByb2PDqWRlcmEgYXUgdHJhbnNmZXJ0IGRpcmVjdCBkZSB0ZXMgZG9ubsOpZXMgw6AgY2FyYWN0w6hyZSBwZXJzb25uZWwgdmVycyBsZSByZXNwb25zYWJsZSBkdSB0cmFpdGVtZW50IGRlIHRvbiBjaG9peCwgZGFucyBsYSBtZXN1cmUgb8O5IGNlbGEgZXN0IHRlY2huaXF1ZW1lbnQgcG9zc2libGUuCk5vdGUgYmllbiBxdeKAmW9uIG7igJllc3QgcGFzIGF1dG9yaXPDqSDDoCB0cmFuc2bDqXJlciBsZXMgZG9ubsOpZXMgcXVpIHBvcnRlbnQgYXR0ZWludGUgYXV4IGxpYmVydMOpcyBldCBhdXggZHJvaXRzIGTigJlhdXRydWksIGNvbmZvcm3DqW1lbnQgw6AgbOKAmWFydGljbGUgMjAsIHBhcmFncmFwaGUgNCwgZHUgUkdQRC4gIDwvcD4KPGgyIGlkPSJqc2VjdGlvbmJlc2Nod2VyZGVyZWNodGJlaWRlcmF1ZnNpY2h0c2JlaHJkZWdlbWFydDc3YWJzMWRzZ3ZvIj5Ecm9pdCBkZSByZWNvdXJzIGF1cHLDqHMgZGUgbCdhdXRvcml0w6kgZGUgY29udHLDtGxlIGNvbmZvcm3DqW1lbnQgw6AgbCdhcnRpY2xlIDc3LCBwYXJhZ3JhcGhlIDEsIGR1IFJHUEQgIDwvaDI+CjxwPlNpIHR1IHNvdXDDp29ubmVzIHF1ZSB0ZXMgZG9ubsOpZXMgc29udCB0cmFpdMOpZXMgZGUgbWFuacOocmUgaWxsaWNpdGUgc3VyIG5vdHJlIHNpdGUsIHR1IHBldXggYmllbiBzw7tyIMOgIHRvdXQgbW9tZW50IHNhaXNpciBsYSBqdXN0aWNlIHBvdXIgcsOpZ2xlciBjZSBwcm9ibMOobWUuClR1IGRpc3Bvc2VzIHBhciBhaWxsZXVycyBkZSB0b3VzIGxlcyBhdXRyZXMgcmVjb3VycyBqdXJpZGlxdWVzIHBvc3NpYmxlcy4KSW5kw6lwZW5kYW1tZW50IGRlIGNlbGEsIGNvbmZvcm3DqW1lbnQgw6AgbOKAmWFydGljbGUgNzcsIHBhcmFncmFwaGUgMSwgZHUgUkdQRCwgdHUgYXMgbGEgcG9zc2liaWxpdMOpIGRlIHTigJlhZHJlc3NlciDDoCB1bmUgYXV0b3JpdMOpIGRlIGNvbnRyw7RsZS4KVHUgZGlzcG9zZXMgZHUgZHJvaXQgZGUgcmVjb3VycyBwcsOpdnUgw6AgbOKAmWFydGljbGUgNzcgZHUgUkdQRCBkYW5zIGzigJnDiXRhdCBtZW1icmUgZGUgbOKAmVVFIG\/DuSB0dSByw6lzaWRlcywgb8O5IHR1IHRyYXZhaWxsZXMgZXQvb3Ugb8O5IGxhIHZpb2xhdGlvbiBwcsOpc3Vtw6llIGEgZXUgbGlldSA7IHR1IHBldXggZG9uYyBjaG9pc2lyIGzigJlhdXRvcml0w6kgZGUgY29udHLDtGxlIMOgIGxhcXVlbGxlIHR1IHTigJlhZHJlc3NlcyBwYXJtaSBsZXMgbGlldXggbWVudGlvbm7DqXMgY2ktZGVzc3VzLgpMJ2F1dG9yaXTDqSBkZSBjb250csO0bGUgYXVwcsOocyBkZSBsYXF1ZWxsZSBsYSByw6ljbGFtYXRpb24gYSDDqXTDqSBkw6lwb3PDqWUgdCdpbmZvcm1lcmEgZW5zdWl0ZSBkZSBsJ8OpdGF0IGQnYXZhbmNlbWVudCBldCBkZXMgcsOpc3VsdGF0cyBkZSB0YSBkZW1hbmRlLCB5IGNvbXByaXMgZGUgbGEgcG9zc2liaWxpdMOpIGQndW4gcmVjb3VycyBqdXJpZGljdGlvbm5lbCBjb25mb3Jtw6ltZW50IMOgIGwnYXJ0aWNsZSA3OCBkdSBSR1BELiAgICA8L3A+PC9kaXY+PHA+Q3LDqcOpIHBhciA6PC9wPjxwPsKpIERVUlkgTEVHQUwgQXZvY2F0cyDigJMgPGEgaHJlZj0iaHR0cHM6Ly93d3cuZHVyeS5kZSIgdGFyZ2V0PSJfYmxhbmsiIHJlbD0ibm9vcGVuZXIiPnd3dy5kdXJ5LmRlPC9hPjwvcD48cD7CqSBXZWJzaXRlLUNoZWNrIEdtYkgg4oCTIDxhIGhyZWY9Imh0dHBzOi8vd3d3LndlYnNpdGUtY2hlY2suZGUiIHRhcmdldD0iX2JsYW5rIiByZWw9Im5vb3BlbmVyIj53d3cud2Vic2l0ZS1jaGVjay5kZTwvYT48L3A+CjwvZGl2Pgo8bm9zY3JpcHQ+CjxpZnJhbWUgc3JjPSJodHRwczovL3NuaXBwZXQubGVnYWwtY2RuLmNvbS92MS9wdWJsaWMvd2Vic2l0ZXMvU3pieDBtVnN2TUpPNzZwOWE2eXF5Y3F5Y1pXMkdPL3BvbGljaWVzL2xhdGVzdC9pZnJhbWUuaHRtbCIgZnJhbWVib3JkZXI9IjAiIHN0eWxlPSJwb3NpdGlvbjogYWJzb2x1dGU7IHdpZHRoOiAxMDAlOyBoZWlnaHQ6IDEwMCU7bGVmdDogMDt0b3A6IDA7Ij4KPC9pZnJhbWU+Cjwvbm9zY3JpcHQ+CjxzY3JpcHQ+CihmdW5jdGlvbigpewp2YXIgd3JhcCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJqbWR3cmFwcGVyLTE3MjI1MDMwNjA0MzIiKTsKaWYgKCF3cmFwKSB7IHdyYXAgPSBkb2N1bWVudC5xdWVyeVNlbGVjdG9yKCdbZGF0YS1qbWR3cmFwcGVyPSIxNzIyNTAzMDYwNDMyIl0nKTsgfQp2YXIgaTsKZnVuY3Rpb24gdHJ5UmVwbGFjZURTRSgpewogIHRyeXsKICAgIHZhciB4bWxIdHRwID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CiAgICB4bWxIdHRwLm9wZW4oICJHRVQiLCAiaHR0cHM6Ly9zbmlwcGV0LmxlZ2FsLWNkbi5jb20vdjEvcHVibGljL3dlYnNpdGVzL1N6YngwbVZzdk1KTzc2cDlhNnlxeWNxeWNaVzJHTy9wb2xpY2llcy9sYXRlc3Qvc25pcHBldC5odG1sIiwgZmFsc2UgKTsKICAgIHhtbEh0dHAuc2VuZCgpOwogICAgaWYgKCh4bWxIdHRwLnN0YXR1cyA8IDIwMCkgfHwgKHhtbEh0dHAuc3RhdHVzID49IDMwMCkpIHsKICAgICAgcmV0dXJuIGZhbHNlOwogICAgfQogICAgd3JhcC5pbm5lckhUTUwgPSB4bWxIdHRwLnJlc3BvbnNlVGV4dDsKICAgIGNsZWFySW50ZXJ2YWwoaSk7CiAgICByZXR1cm4gdHJ1ZTsKICB9IGNhdGNoKGV4KXsKICAgIHJldHVybiBmYWxzZTsKICB9Cn0KaWYoIXRyeVJlcGxhY2VEU0UoKSl7CiAgICBpID0gc2V0SW50ZXJ2YWwodHJ5UmVwbGFjZURTRSwgMjAwMCk7Cn0KfSkoKTsKPC9zY3JpcHQ+CjwvZGl2Pg==[\/vc_raw_html][\/vc_column][\/vc_row][\/vc_section]<\/p>\n<\/div>","protected":false},"excerpt":{"rendered":"<p>[vc_section][vc_row][vc_column width=&#8221;1\/1&#8243;][vc_raw_html]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[\/vc_raw_html][\/vc_column][\/vc_row][\/vc_section]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"class_list":["post-58223","page","type-page","status-publish","hentry"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.0 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Protection des donn\u00e9es - tiSsi\u00ae<\/title>\n<meta name=\"description\" content=\"On accorde une grande importance \u00e0 la protection de tes donn\u00e9es quand tu utilises notre site web. On a rassembl\u00e9 ici toutes les informations utiles \u00e0 ce sujet.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/tissi.de\/fr\/protection-des-donnees\/\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Protection des donn\u00e9es - tiSsi\u00ae\" \/>\n<meta property=\"og:description\" content=\"On accorde une grande importance \u00e0 la protection de tes donn\u00e9es quand tu utilises notre site web. On a rassembl\u00e9 ici toutes les informations utiles \u00e0 ce sujet.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/tissi.de\/fr\/protection-des-donnees\/\" \/>\n<meta property=\"og:site_name\" content=\"tiSsi\u00ae\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/de-de.facebook.com\/tiSsikids\/\" \/>\n<meta property=\"article:modified_time\" content=\"2026-06-25T02:48:20+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/tissi.de\/wp-content\/uploads\/2022\/04\/family-business-tissi.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"681\" \/>\n\t<meta property=\"og:image:height\" content=\"418\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Dur\u00e9e de lecture estim\u00e9e\" \/>\n\t<meta name=\"twitter:data1\" content=\"67 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/tissi.de\\\/fr\\\/protection-des-donnees\\\/\",\"url\":\"https:\\\/\\\/tissi.de\\\/fr\\\/protection-des-donnees\\\/\",\"name\":\"Protection des donn\u00e9es - tiSsi\u00ae\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/tissi.de\\\/fr\\\/#website\"},\"datePublished\":\"2021-10-09T10:52:47+00:00\",\"dateModified\":\"2026-06-25T02:48:20+00:00\",\"description\":\"On accorde une grande importance \u00e0 la protection de tes donn\u00e9es quand tu utilises notre site web. On a rassembl\u00e9 ici toutes les informations utiles \u00e0 ce sujet.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/tissi.de\\\/fr\\\/protection-des-donnees\\\/#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/tissi.de\\\/fr\\\/protection-des-donnees\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/tissi.de\\\/fr\\\/protection-des-donnees\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Startseite\",\"item\":\"https:\\\/\\\/tissi.de\\\/fr\\\/accueil\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Protection des donn\u00e9es\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/tissi.de\\\/fr\\\/#website\",\"url\":\"https:\\\/\\\/tissi.de\\\/fr\\\/\",\"name\":\"tiSsi\u00ae\",\"description\":\"Familie beginnt mit uns! Lernturm, Hochstuhl, Kinderm\u00f6bel, Laufgitter\",\"publisher\":{\"@id\":\"https:\\\/\\\/tissi.de\\\/fr\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/tissi.de\\\/fr\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"fr-FR\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/tissi.de\\\/fr\\\/#organization\",\"name\":\"M.J. Oster GmbH\",\"url\":\"https:\\\/\\\/tissi.de\\\/fr\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/tissi.de\\\/fr\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/tissi.de\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/tissi-logo.webp\",\"contentUrl\":\"https:\\\/\\\/tissi.de\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/tissi-logo.webp\",\"width\":300,\"height\":188,\"caption\":\"M.J. Oster GmbH\"},\"image\":{\"@id\":\"https:\\\/\\\/tissi.de\\\/fr\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/de-de.facebook.com\\\/tiSsikids\\\/\",\"https:\\\/\\\/www.instagram.com\\\/tissi_kids\\\/\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Protection des donn\u00e9es - tiSsi\u00ae","description":"On accorde une grande importance \u00e0 la protection de tes donn\u00e9es quand tu utilises notre site web. On a rassembl\u00e9 ici toutes les informations utiles \u00e0 ce sujet.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/tissi.de\/fr\/protection-des-donnees\/","og_locale":"fr_FR","og_type":"article","og_title":"Protection des donn\u00e9es - tiSsi\u00ae","og_description":"On accorde une grande importance \u00e0 la protection de tes donn\u00e9es quand tu utilises notre site web. On a rassembl\u00e9 ici toutes les informations utiles \u00e0 ce sujet.","og_url":"https:\/\/tissi.de\/fr\/protection-des-donnees\/","og_site_name":"tiSsi\u00ae","article_publisher":"https:\/\/de-de.facebook.com\/tiSsikids\/","article_modified_time":"2026-06-25T02:48:20+00:00","og_image":[{"width":681,"height":418,"url":"https:\/\/tissi.de\/wp-content\/uploads\/2022\/04\/family-business-tissi.jpg","type":"image\/jpeg"}],"twitter_card":"summary_large_image","twitter_misc":{"Dur\u00e9e de lecture estim\u00e9e":"67 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/tissi.de\/fr\/protection-des-donnees\/","url":"https:\/\/tissi.de\/fr\/protection-des-donnees\/","name":"Protection des donn\u00e9es - tiSsi\u00ae","isPartOf":{"@id":"https:\/\/tissi.de\/fr\/#website"},"datePublished":"2021-10-09T10:52:47+00:00","dateModified":"2026-06-25T02:48:20+00:00","description":"On accorde une grande importance \u00e0 la protection de tes donn\u00e9es quand tu utilises notre site web. On a rassembl\u00e9 ici toutes les informations utiles \u00e0 ce sujet.","breadcrumb":{"@id":"https:\/\/tissi.de\/fr\/protection-des-donnees\/#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/tissi.de\/fr\/protection-des-donnees\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/tissi.de\/fr\/protection-des-donnees\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Startseite","item":"https:\/\/tissi.de\/fr\/accueil\/"},{"@type":"ListItem","position":2,"name":"Protection des donn\u00e9es"}]},{"@type":"WebSite","@id":"https:\/\/tissi.de\/fr\/#website","url":"https:\/\/tissi.de\/fr\/","name":"tiSsi\u00ae","description":"Familie beginnt mit uns! Lernturm, Hochstuhl, Kinderm\u00f6bel, Laufgitter","publisher":{"@id":"https:\/\/tissi.de\/fr\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/tissi.de\/fr\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"fr-FR"},{"@type":"Organization","@id":"https:\/\/tissi.de\/fr\/#organization","name":"M.J. Oster GmbH","url":"https:\/\/tissi.de\/fr\/","logo":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/tissi.de\/fr\/#\/schema\/logo\/image\/","url":"https:\/\/tissi.de\/wp-content\/uploads\/2022\/04\/tissi-logo.webp","contentUrl":"https:\/\/tissi.de\/wp-content\/uploads\/2022\/04\/tissi-logo.webp","width":300,"height":188,"caption":"M.J. Oster GmbH"},"image":{"@id":"https:\/\/tissi.de\/fr\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/de-de.facebook.com\/tiSsikids\/","https:\/\/www.instagram.com\/tissi_kids\/"]}]}},"_links":{"self":[{"href":"https:\/\/tissi.de\/fr\/wp-json\/wp\/v2\/pages\/58223","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/tissi.de\/fr\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/tissi.de\/fr\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/tissi.de\/fr\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/tissi.de\/fr\/wp-json\/wp\/v2\/comments?post=58223"}],"version-history":[{"count":2,"href":"https:\/\/tissi.de\/fr\/wp-json\/wp\/v2\/pages\/58223\/revisions"}],"predecessor-version":[{"id":58225,"href":"https:\/\/tissi.de\/fr\/wp-json\/wp\/v2\/pages\/58223\/revisions\/58225"}],"wp:attachment":[{"href":"https:\/\/tissi.de\/fr\/wp-json\/wp\/v2\/media?parent=58223"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}