• >
  • >
  • PHOTOS - 10 ans de Star Academy : que sont devenus les candidats des saisons 1 à 4 ?

PHOTOS - 10 ans de Star Academy : que sont devenus les candidats des saisons 1 à 4 ?

09/12/2011 - 18h30
  • 10
Voir toutes les photos (67)Toutes les photos (67)
  • 10 ans de Star Academy : que sont devenus les candidats des saisons 1 à 4 ? Jenifer Bartoli (saison 1) Khalifa M'baye (saison 1) Djalil Amine (saison 1) Carine Goossens-Haddadou (saison 1) Cécile Boutry (saison 1) François Roure (saison 1) Stéphane Bosmans (saison 1) Patrice Maktav (saison 1) Olivia Ruiz (saison 1) Amandine Bisqueret (saison 1) Catherine (saison 1) Mario Barravecchia (saison 1) Jessica Márquez (saison 1) Jean-Pascal Lacoste (saison 1) Grégory Gulli (saison 1) Sidonie Koch (saison 1) Houcine Camara (saison 2)
  • Nazim Djad (saison 2) Nolwenn Leroy (saison 2) Florence Morissonneau (saison 2) Rudy Carvalho (saison 2) Aurélie Konaté (saison 2) Anne-Laure Sibon (saison 2) Isabelle Lemoine (saison 2) Fabien Fasake (saison 2) Jérémy Chatelain (saison 2) Stéphanie Hansen (saison 2) Eva Chimouni-Arbib (saison 2) Alexandre Balduzzi (saison 2) Philippe Miro (saison 2) Georges-Alain Jones (saison 2) Emma Daumas (saison 2) Morganne Matis (saison 3) Elodie Frégé (saison 3) Marjorie Condoris (saison 3)
  • Anne Thibault (saison 3) Sofia Essaïdi (saison 3) Michaël Sapience (saison 3) Icaro Jorge (saison 3) Romain Wylson (saison 3) Michał Kwiatkowski (saison 3) Stéphanie D'Alma (saison 3) Amina Benounni (saison 3) Patxi Garat (saison 3) Edouard Algayon (saison 3) Lukas Delcourt (saison 3) Pierre Nesta (saison 3) Valérie Deniz (saison 3) Harlem Harl (saison 4) Sandy François (saison 4) Hoda Sanz (saison 4) Karima Charni (saison 4) John Eyzen (saison 4)
  • Gauthier Roubichou (saison 4) Morgan Auger (saison 4) Tina Tictone (saison 4) Lennie Marshall (saison 4) Radia Bensarsa (saison 4) Mathieu Johann (saison 4) Sébastien Degut (saison 4) Émilie Ducrot (saison 4) Enrique Toyos (saison 4) Grégory Lemarchal (saison 4) Lucie Bernardoni (saison 4) Francesca Antoniotti (saison 4) Sofiane Tadjine-Lambert (saison 4)
  • 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
  • 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
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5OTAiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2toYWxpZmEtbS1iYXllLXNhaXNvbi0xLzUyNDc0OTc0LTEtZnJlLUZSL0toYWxpZmEtTS1iYXllLXNhaXNvbi0xX3BvcnRyYWl0X3c4NTguanBnIiB3aWR0aD0iODU4IiBoZWlnaHQ9IjU1OCIgIHN0eWxlPSJib3JkZXI6IDBweCAgOyIgYWx0PSJLaGFsaWZhIE0nYmF5ZSAgKHNhaXNvbiAxKSIgdGl0bGU9IktoYWxpZmEgTSdiYXllICAoc2Fpc29uIDEpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGVtPiZjb3B5OyBHT05HT1JBIE1hcmllLUFubmU8L2VtPjwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+S2hhbGlmYSBNJ2JheWUgIChzYWlzb24gMSk8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD5Tb24gcGh5c2lxdWUgZCdhdGhsw6h0ZSBsdWkgcGVybWV0IGQnw6p0cmUgcmVww6lyw6kgZXQgZGUgcGFydGljaXBlciDDoCBkZXMgZMOpZmlsw6lzLiBLaGFsaWZhIGVzdCDDqWdhbGVtZW50IHVuIGFydGlzdGUgZW5nYWfDqSBwdWlzcXUnaWwgZXN0IHVuIGRlcyA4IG1lbWJyZXMgZGUgbCdhc3NvY2lhdGlvbiBDaMOqbmVzIGV0IEJhb2JhYnMgU29saWRhcml0w6kuIElsIGVzdCBsZSBnw6lyYW50IGRlIGxhIHNvY2nDqXTDqSBFcXVhdGlvbnMgw6AgQ3LDqXRlaWwsIHNww6ljaWFsaXPDqWUgZGFucyBsYSBmb3JtYXRpb24gY29udGludWUgZCdhZHVsdGVzLiZuYnNwOyBFbiAyMDEwLCBpbCBzb3J0IGxlIHNpbmdsZSA8aT5Ub3V0IGNlIHF1ZSB0dSB2ZXV4LjwvaT4g77u/PC9wPjwvc3Bhbj4=
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5NjAiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2RqYWxpbC1hbWluZS1zYWlzb24tMS81MjQ3NDcwNC0xLWZyZS1GUi9EamFsaWwtQW1pbmUtc2Fpc29uLTFfcG9ydHJhaXRfdzg1OC5qcGciIHdpZHRoPSI4NTgiIGhlaWdodD0iMTMxNiIgIHN0eWxlPSJib3JkZXI6IDBweCAgOyIgYWx0PSJEamFsaWwgQW1pbmUgKHNhaXNvbiAxKSIgdGl0bGU9IkRqYWxpbCBBbWluZSAoc2Fpc29uIDEpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGVtPiZjb3B5OyBHT05HT1JBIE1hcmllLUFubmU8L2VtPjwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+RGphbGlsIEFtaW5lIChzYWlzb24gMSk8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD5JbCBzZSBub21tZSDDoCBwcsOpc2VudCBEamFsaWwgQXltYXIuIElsIHNvcnQgbGUgMTIgbWFycyAyMDAyIHNvbiBwcmVtaWVyIHNpbmdsZSwgPGk+QXUgcGF5cyBkZSBtZXMgcsOqdmVzPC9pPiwgZG9udCBpbCBhIMOpY3JpdCBsZXMgcGFyb2xlcyBldCBsYSBtdXNpcXVlLiBJbCBhIHBhcnRpY2lww6kgYXUgRFZEIGRlIGNvdXJzIGRlIGNoYW50IGRlIDxhIGhyZWY9Imh0dHA6Ly93d3cucHJlbWllcmUuZnIvU3Rhci9NYXR0aGlldS1Hb25ldC0xOTk2NzcxIiB0YXJnZXQ9Il9zZWxmIj5NYXR0aGlldSBHb25ldDwvYT4uJm5ic3A7IExlIGRldXhpw6htZSBzaW5nbGUgUG9wdWxhaXJlIG4nYSBwYXMgc8OpZHVpdCwgbGUgcmVzdGUgZXN0IHJlc3TDqSBkYW5zIHVuIHRpcm9pci4gRmluIGp1aWxsZXQgMjAwNCwgaWwgcGFydCBlbiBFc3BhZ25lIG/DuSBpbCBwcmVuZCBkZXMgY291cnMgZGUgZ3VpdGFyZSBldCDDqWNyaXQgZXQgY29tcG9zZSBkZSBub3V2ZWxsZXMgY2hhbnNvbnMuIERlcHVpcywgaWwgYSBvdXZlcnQgdW5lIHNvY2nDqXTDqSBk4oCZw6l2w6huZW1lbnRpZWwgw6AgQ3LDqXRlaWwuPC9wPjwvc3Bhbj4=
  • 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
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5NjYiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2NlY2lsZS1ib3V0cnktc2Fpc29uLTEvNTI0NzQ3NTgtMS1mcmUtRlIvQ2VjaWxlLUJvdXRyeS1zYWlzb24tMV9wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMzE2IiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9IkPDqWNpbGUgQm91dHJ5IChzYWlzb24gMSkiIHRpdGxlPSJDw6ljaWxlIEJvdXRyeSAoc2Fpc29uIDEpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGVtPiZjb3B5OyBHT05HT1JBIE1hcmllLUFubmU8L2VtPjwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+Q8OpY2lsZSBCb3V0cnkgKHNhaXNvbiAxKTwvc3Bhbj48L3N0cm9uZz4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHNwYW4gY2xhc3M9ImRpYXBvX2Rlc2NyaXB0aW9uX2l0ZW0iPjxwPkVsbGUgZXN0IHJlbnRyw6llIGVuIHN0dWRpbyBlbiBkw6ljZW1icmUgMjAwNCBwb3VyIGVuIHNvcnRpciBlbiBtYXJzIDIwMDUsIGxlIHRpdHJlIDxpPkMnZXN0IGxhIGZvbGllPC9pPiBlbiBkdW8gYXZlYyBsZSBjaGFudGV1ciBNaWNoYWVsIEZvcnR1bmF0aS4gQ2UgdGl0cmUgbidhIGjDqWxhcyBwYXMgZXUgbGUgc3VjY8OocyBlc2NvbXB0w6kuIEPDqWNpbGUgZGV2aWVudCBMaWxpYmVsbGUgZXQgcydhc3NvY2llIGF2ZWMgUlYgVHJlemVuIChleCBjaGFudGV1ciBkZSBNYW5hdSkgZXQgRmFiaW8gQ2F6YW5vIHBvdXIgZm9ybWVyIGxlIGdyb3VwZSBQTlBDIChQaWNhcmRpZSBOb3JkLVBhcy1EZS1DYWxhaXMpLiDvu788L3A+PC9zcGFuPg==
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5NjgiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2ZyYW5jb2lzLXJvdXJlLXNhaXNvbi0xLzUyNDc0Nzc2LTEtZnJlLUZSL0ZyYW5jb2lzLVJvdXJlLXNhaXNvbi0xX3BvcnRyYWl0X3c4NTguanBnIiB3aWR0aD0iODU4IiBoZWlnaHQ9IjEzMTYiICBzdHlsZT0iYm9yZGVyOiAwcHggIDsiIGFsdD0iRnJhbsOnb2lzIFJvdXJlIChzYWlzb24gMSkiIHRpdGxlPSJGcmFuw6dvaXMgUm91cmUgKHNhaXNvbiAxKSIgICAvPgogICAgICAgICAgICAKICAgIAogICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxlbT4mY29weTsgR09OR09SQSBNYXJpZS1Bbm5lPC9lbT48L3NwYW4+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3Ryb25nPjxzcGFuPkZyYW7Dp29pcyBSb3VyZSAoc2Fpc29uIDEpPC9zcGFuPjwvc3Ryb25nPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBjbGFzcz0iZGlhcG9fZGVzY3JpcHRpb25faXRlbSI+PHA+RW4gMjAwMiwgaWwgc29ydCBsZSBzaW5nbGUgPGk+RW52aWUgbWkgYW1vciA8L2k+cXVpIHBhc3NlIGluYXBlcsOndS4gSWwmbmJzcDsgcmVqb2ludCBldCBkaXJpZ2UgdW5lIGNob3JhbGUgcXXigJlpbCBhIHByw6lzZW50w6llIGVuIDIwMDkgYXUgY2FzdGluZyBkZSA8aT48YSBocmVmPSJodHRwOi8vdGVsZS5wcmVtaWVyZS5mci9YLUZhY3Rvci0yMDA5LTI0MzY2NDQiIHRhcmdldD0iX3NlbGYiPlggRmFjdG9yPC9hPjwvaT4uIExhIHByZXN0YXRpb24gZsO7dCBlbnRhY2jDqWUgZXQgw6ljb3VydMOpZSBwYXIgRnJhbsOnb2lzIHF1aSBu4oCZYWNjZXB0YSBwYXMgbGVzIGNyaXRpcXVlcyBkdSBqdXJ5LiDvu788L3A+PC9zcGFuPg==
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5NzAiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL3N0ZXBoYW5lLWJvc21hbnMtc2Fpc29uLTEvNTI0NzQ3OTQtMS1mcmUtRlIvU3RlcGhhbmUtQm9zbWFucy1zYWlzb24tMV9wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMzE2IiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9IlN0w6lwaGFuZSBCb3NtYW5zIChzYWlzb24gMSkiIHRpdGxlPSJTdMOpcGhhbmUgQm9zbWFucyAoc2Fpc29uIDEpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGVtPiZjb3B5OyBHT05HT1JBIE1hcmllLUFubmU8L2VtPjwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+U3TDqXBoYW5lIEJvc21hbnMgKHNhaXNvbiAxKTwvc3Bhbj48L3N0cm9uZz4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHNwYW4gY2xhc3M9ImRpYXBvX2Rlc2NyaXB0aW9uX2l0ZW0iPjxwPklsIHJlc3RlIGFtYml0aWV1eCwgdG91dCBlbiBjb250aW51YW50IGxlcyBkw6lmaWzDqXMsIGlsIHRlbnRlIGRlIHBlcmNlciBkYW5zIGxhIGNoYW5zb24gZXQgZnJhcHBlIGF1eCBwb3J0ZXMgZGVzIHByb2R1Y3RldXJzLiBJbCBzaWduZSBhdXByw6hzIGQnT3JsYW5kbywgcHJvZHVjdGV1ciBkJzxhIGhyZWY9Imh0dHA6Ly93d3cucHJlbWllcmUuZnIvU3Rhci9IZWxlbmUtU2VnYXJhLTIxMDg4MjEiIHRhcmdldD0iX3NlbGYiPkjDqWzDqG5lIFPDqWdhcmE8L2E+IGV0IHRyYXZhaWxsZSBzdXIgZGVzIG1hcXVldHRlcy7vu788L3A+PC9zcGFuPg==
  • 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
  • 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
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5NzYiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2FtYW5kaW5lLWJpc3F1ZXJldC1zYWlzb24tMS81MjQ3NDg0OC0xLWZyZS1GUi9BbWFuZGluZS1CaXNxdWVyZXQtc2Fpc29uLTFfcG9ydHJhaXRfdzg1OC5qcGciIHdpZHRoPSI4NTgiIGhlaWdodD0iMTMxNiIgIHN0eWxlPSJib3JkZXI6IDBweCAgOyIgYWx0PSJBbWFuZGluZSBCaXNxdWVyZXQgKHNhaXNvbiAxKSIgdGl0bGU9IkFtYW5kaW5lIEJpc3F1ZXJldCAoc2Fpc29uIDEpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGVtPiZjb3B5OyBHT05HT1JBIE1hcmllLUFubmU8L2VtPjwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+QW1hbmRpbmUgQmlzcXVlcmV0IChzYWlzb24gMSk8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD5BIHNhIHNvcnRpZSwgZWxsZSBhIGluY2FybsOpIGxlIHLDtGxlIGRlIGxhIGJlbGxlIGR1IG5vdXZlYXUgbW9uZGUgZGFucyBsYSBjb23DqWRpZSBtdXNpY2FsZSBBcmVuYmVyZy4gRW4gZsOpdnJpZXIgMjAwNCwgZWxsZSBpbnTDqGdyZSB1biBncm91cGUgZGUgcm9jayBMYXJ6ZW4uIEVuIDIwMDcsIGFwcsOocyB1biBiaWxhbiBwZXJzb25uZWwsIEFtYW5kaW5lIGNob2lzaSBkJ29yaWVudGVyIHNvbiBjaG9peCB2ZXJzIGQnYXV0cmVzIGFycmFuZ2VtZW50cyBldCBkZSBub3V2ZWxsZXMgY291bGV1cnMgbXVzaWNhbGVzLiBIZXJ2w6ksIFBpdCBldCBBZGFtLCBsZXMgbWVtYnJlcyBkdSBncm91cGUgY3LDqWVudCB1biBhdXRyZSBncm91cGUgQ2VkcmEsIHRhbmRpcyBxdSdBbWFuZGluZSBzZSBsYW5jZSBkYW5zIHVuIHByb2pldCBzb2xvLiBFbGxlIHPigJllc3QgaW5zY3JpdGUgc3VyIE15TWFqb3JDb21wYW55IHNvdXMgbGUgcHNldWRvbnltZSBkZSBNYW3igJl6ZWxsZSBNYW5kYXJpbmUgYWZpbiBxdWUgbGVzIGludGVybmF1dGVzIHByb2R1aXNlbnQgc29uIGFsYnVtLjwvcD48L3NwYW4+
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5NzgiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2NhdGhlcmluZS1zYWlzb24tMS81MjQ3NDg2Ni0xLWZyZS1GUi9DYXRoZXJpbmUtc2Fpc29uLTFfcG9ydHJhaXRfdzg1OC5qcGciIHdpZHRoPSI4NTgiIGhlaWdodD0iMTMxNiIgIHN0eWxlPSJib3JkZXI6IDBweCAgOyIgYWx0PSJDYXRoZXJpbmUgIChzYWlzb24gMSkiIHRpdGxlPSJDYXRoZXJpbmUgIChzYWlzb24gMSkiICAgLz4KICAgICAgICAgICAgCiAgICAKICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8ZW0+JmNvcHk7IEdPTkdPUkEgTWFyaWUtQW5uZTwvZW0+PC9zcGFuPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHN0cm9uZz48c3Bhbj5DYXRoZXJpbmUgIChzYWlzb24gMSk8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD5EZXZlbnVlIExhZHkgQmlyZCwgbGEgY2hhbnRldXNlIG7igJlhIGphbWFpcyBwdSB0b3VjaGVyIGxlIHN1Y2PDqHMgZGVzIGRvaWd0cyBtYWxncsOpIHVuIGFsYnVtIDkgdGl0cmVzIHNvcnRpIHRyb2lzIGFucyBwbHVzIHRhcmQuPC9wPjwvc3Bhbj4=
  • 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
  • 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
  • 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
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5ODYiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2dyZWdvcnktZ3VsbGktc2Fpc29uLTEvNTI0NzQ5MzgtMS1mcmUtRlIvR3JlZ29yeS1HdWxsaS1zYWlzb24tMV9wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMzE2IiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9Ikdyw6lnb3J5IEd1bGxpIChzYWlzb24gMSkiIHRpdGxlPSJHcsOpZ29yeSBHdWxsaSAoc2Fpc29uIDEpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGVtPiZjb3B5OyBHT05HT1JBIE1hcmllLUFubmU8L2VtPjwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+R3LDqWdvcnkgR3VsbGkgKHNhaXNvbiAxKTwvc3Bhbj48L3N0cm9uZz4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHNwYW4gY2xhc3M9ImRpYXBvX2Rlc2NyaXB0aW9uX2l0ZW0iPjxwPkFwcsOocyBsYSB0b3VybsOpZSBTdGFyIEFjJywgaWwgc29ydCB1biBzaW5nbGUgPGk+RGVtYWluIDwvaT5xdWkgbmUgdHJvdXZlIHBhcyBsZSBzdWNjw6hzIG3DqXJpdMOpIGV0IHNlIHZlbmQgw6AgMzkgMDAwIGV4ZW1wbGFpcmVzLiBBcHLDqHMgbGEgdG91cm7DqWUsIEdyw6lnb3J5IGTDqWNpZGUgZGUgcmVub3VlciBhdmVjIHNhIHZpZSBkJ2F2YW50IGV0IHRlbnRlIGRlIHNlIGZhaXJlIG91YmxpZXIuIElsIGEgcmVwcmlzIGVuIG1haW4gdW5lIGJvw650ZSBk4oCZaW5mb3JtYXRpcXVlIG91dmVydGUgYXZhbnQgc2EgcGFydGljaXBhdGlvbiBhdSBwcm9ncmFtbWUuIO+7vzwvcD48L3NwYW4+
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5ODgiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL3NpZG9uaWUta29jaC1zYWlzb24tMS81MjQ3NDk1Ni0xLWZyZS1GUi9TaWRvbmllLUtvY2gtc2Fpc29uLTFfcG9ydHJhaXRfdzg1OC5qcGciIHdpZHRoPSI4NTgiIGhlaWdodD0iMTMxNiIgIHN0eWxlPSJib3JkZXI6IDBweCAgOyIgYWx0PSJTaWRvbmllIEtvY2ggKHNhaXNvbiAxKSIgdGl0bGU9IlNpZG9uaWUgS29jaCAoc2Fpc29uIDEpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGVtPiZjb3B5OyBHT05HT1JBIE1hcmllLUFubmU8L2VtPjwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+U2lkb25pZSBLb2NoIChzYWlzb24gMSk8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD5FbGxlIGEgcXVpdHTDqSBsYSBGcmFuY2UgcG91ciByZXRvdXJuZXIgdml2cmUgYXUgQ2FuYWRhIGF2ZWMgc2EgZmlsbGUgZXQgYSBvdXZlcnQgc2EgYm91dGlxdWUgZGUgcHLDqnQtw6AtcG9ydGVyLiBFbGxlIGVzdCBlbnN1aXRlIGRldmVudWUgdW5lIGFydGlzdGUgY29udGVtcG9yYWluZSBkb250IGxlcyB0b2lsZXMgc29udCByZW1wbGllcyBkZSBjb2xsYWdlcyBldCBk4oCZaW1hZ2VzIHJlY3ljbMOpZXMuPC9wPjwvc3Bhbj4=
  • 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
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5MDYiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL25hemltLWRqYWQtc2Fpc29uLTIvNTI0NzQyMjAtMS1mcmUtRlIvTmF6aW0tRGphZC1zYWlzb24tMl9wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMjU4IiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9Ik5hemltIERqYWQgIChzYWlzb24gMikiIHRpdGxlPSJOYXppbSBEamFkICAoc2Fpc29uIDIpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9zcGFuPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHN0cm9uZz48c3Bhbj5OYXppbSBEamFkICAoc2Fpc29uIDIpPC9zcGFuPjwvc3Ryb25nPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBjbGFzcz0iZGlhcG9fZGVzY3JpcHRpb25faXRlbSI+PHA+QSBwZWluZSBsYSBTdGFyIEFjYWRlbXkgdG91Y2hlIMOgIHNhIGZpbiBlbiBkw6ljZW1icmUgMjAwMiwgcXVlIE5hemltIGF2ZWMgY2VydGFpbnMgMWVycyDDqWxpbWluw6lzIGRlIGwnw6ltaXNzaW9uIGTDqWNpZGVudCBkZSBjcsOpZXIgbGV1ciBwcm9wcmUgZ3JvdXBlLCBTdGFyIENvbGxlY3Rpb24uIE5hemltIGVzdCB0b3Vqb3VycyBkYW5zIGxlIG1pbGlldSBkZSBsYSBtdXNpcXVlIGV0IHNlIHByb2R1aXQgYXZlYyBkaWZmw6lyZW50cyBncm91cGVzIGVuIEZyYW5jZSBldCDDoCBsJ8OpdHJhbmdlci4gSWwgcGxhbmNoZSBhdXNzaSBzdXIgZGVzIG1hcXVldHRlcyBkYW5zIGwnZXNwb2lyIGRlIHNvcnRpciB1biBqb3VyIHVuIGFsYnVtLiDvu788L3A+PC9zcGFuPg==
  • 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
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5MDIiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2Zsb3JlbmNlLW1vcmlzc29ubmVhdS1zYWlzb24tMi81MjQ3NDE4NC0xLWZyZS1GUi9GbG9yZW5jZS1Nb3Jpc3Nvbm5lYXUtc2Fpc29uLTJfcG9ydHJhaXRfdzg1OC5qcGciIHdpZHRoPSI4NTciIGhlaWdodD0iMjIzOCIgIHN0eWxlPSJib3JkZXI6IDBweCAgOyIgYWx0PSJGbG9yZW5jZSBNb3Jpc3Nvbm5lYXUgKHNhaXNvbiAyKSIgdGl0bGU9IkZsb3JlbmNlIE1vcmlzc29ubmVhdSAoc2Fpc29uIDIpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGVtPiZjb3B5OyBKZWFuLU1hcmMgSEFFRFJJQ0ggLyBWSVNVQUwgUHJlczwvZW0+PC9zcGFuPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHN0cm9uZz48c3Bhbj5GbG9yZW5jZSBNb3Jpc3Nvbm5lYXUgKHNhaXNvbiAyKTwvc3Bhbj48L3N0cm9uZz4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHNwYW4gY2xhc3M9ImRpYXBvX2Rlc2NyaXB0aW9uX2l0ZW0iPjxwPkVuIDIwMDcsIEZsb3JlbmNlIGVzdCDDoCBsJ2FmZmljaGUgZGUgZGV1eCBjb3VydHMgbcOpdHJhZ2VzLCBIdW50IGV0IFRoZSBHYW1lIDsgZW4gMjAwOCwgb24gbGEgcmV0cm91dmUgZGFucyBsYSBzw6lyaWUgPGk+PGEgaHJlZj0iaHR0cDovL3Nlcmllcy10di5wcmVtaWVyZS5mci9QYXMtZGUtc2VjcmV0cy1lbnRyZS1ub3VzLTE1OTgxMjEiIHRhcmdldD0iX3NlbGYiPlBhcyBkZSBTZWNyZXRzIGVudHJlIG5vdXM8L2E+PC9pPiBkaWZmdXPDqWUgc3VyIE02LiBBdWpvdXJkJ2h1aSwgRmxvcmVuY2UgY29udGludWUgZCdlbmNoYcOubmVyIGxlcyBhdWRpdGlvbnMgdG91dCBlbiBzJ2Vzc2F5YW50IMOpZ2FsZW1lbnQgZGFucyBsZSBtb25kZSBkZSBsYSBtb2RlLCBvw7kgZWxsZSBwcmVuZCBsYSBwb3NlIGxvcnMgZGUgc8OpYW5jZXMgcGhvdG9zIGVuIHRhbnQgcXVlIG1vZMOobGUuJm5ic3A7IO+7vzwvcD48L3NwYW4+
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5MTAiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL3J1ZHktY2FydmFsaG8tc2Fpc29uLTIvNTI0NzQyNTYtMS1mcmUtRlIvUnVkeS1DYXJ2YWxoby1zYWlzb24tMl9wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1NyIgaGVpZ2h0PSI1ODIiICBzdHlsZT0iYm9yZGVyOiAwcHggIDsiIGFsdD0iUnVkeSBDYXJ2YWxobyAoc2Fpc29uIDIpIiB0aXRsZT0iUnVkeSBDYXJ2YWxobyAoc2Fpc29uIDIpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9zcGFuPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHN0cm9uZz48c3Bhbj5SdWR5IENhcnZhbGhvIChzYWlzb24gMik8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD5SdWR5IGludMOoZ3JlIGxlIGdyb3VwZSBmb3Jtw6kgYXZlYyBkZXMgYW5jaWVucywgU3RhciBDb2xsZWN0aW9uLiBJbCBlc3QgZW5zdWl0ZSBlbWJhdWNow6kgZGFucyB1biBvcmNoZXN0cmUgZHUgc3VkIGRlIGxhIEZyYW5jZSA6IExpdmVycG9vbC4gQ2V0dGUgZm9ybWF0aW9uIHNlIHByb2R1aXQgZW4gRnJhbmNlIGV0IMOgIGwnw6l0cmFuZ2VyLiBSdWR5IGEgZmFpdCB1biBicmVmIHJldG91ciDDoCBsYSB0w6lsw6l2aXNpb24gZGFucyBMYSBtw6l0aG9kZSBDYXVldCBkdSBqZXVkaSA4IG5vdmVtYnJlIDIwMDcgZGFucyB1bmUgc3DDqWNpYWxlIGFuY2llbnMgZGUgbGEgU3RhciBBYy4gQXByw6hzIGRlcyBzb3VjaXMgZGUgY29yZGVzIHZvY2FsLCBsZSBqZXVuZSBob21tZSBhIHJlbm9uY8OpIMOgIGxhIGNoYW5zb24uIFJ1ZHkgZXN0IMOgIHByw6lzZW50IGRhbnMgbGVzIGFmZmFpcmVzIGV0IGEgcXVpdHTDqSBsYSBGcmFuY2UuIO+7vzwvcD48L3NwYW4+
  • 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
  • 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
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5MTYiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2lzYWJlbGxlLWxlbW9pbmUtc2Fpc29uLTIvNTI0NzQzMTAtMS1mcmUtRlIvSXNhYmVsbGUtTGVtb2luZS1zYWlzb24tMl9wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMjQ3IiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9IklzYWJlbGxlIExlbW9pbmUgKHNhaXNvbiAyKSIgdGl0bGU9IklzYWJlbGxlIExlbW9pbmUgKHNhaXNvbiAyKSIgICAvPgogICAgICAgICAgICAKICAgIAogICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+SXNhYmVsbGUgTGVtb2luZSAoc2Fpc29uIDIpPC9zcGFuPjwvc3Ryb25nPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBjbGFzcz0iZGlhcG9fZGVzY3JpcHRpb25faXRlbSI+PHA+QSBwZWluZSBsYSBTdGFyIEFjYWRlbXkgdG91Y2hlIMOgIHNhIGZpbiBlbiBkw6ljZW1icmUgMjAwMiwgcXUnSXNhYmVsbGUgYXZlYyBjZXJ0YWlucyAxZXJzIMOpbGltaW7DqXMgZGUgbCfDqW1pc3Npb24gZMOpY2lkZSBkZSBjcsOpZXIgbGV1ciBwcm9wcmUgZ3JvdXBlLiBDZWx1aS1jaSBzZSBub21tZSBTdGFyIENvbGxlY3Rpb24gZXQgZXN0IGNvbXBvc8OpIGRlIDUgbWVtYnJlcy4gRW4gMjAwNCwgSXNhYmVsbGUgYSBmaW5hbGlzw6kgdW4gc2luZ2xlIEonZXNzYWllcmFpIGVuY29yZS4gRW4gcGFyYWxsw6hsZSwgSXNhYmVsbGUgZXN0IG1hbm5lcXVpbiBwb3VyIGRlcyB2w6p0ZW1lbnRzIMOgIGRlc3RpbmF0aW9uIGRlIGZlbW1lcyBwdWxwZXVzZXMuIEVsbGUgYSBkb25jIHJlcHJpcyBzZXMgYWN0aXZpdMOpcyBldCBlc3QgcHJvZmVzc2V1ciBkZSBmaXRuZXNzIGF1IEx1eGVtYm91Zy4gRWxsZSBlc3QgYXVzc2kgZGV2ZW51ZSBtw6hyZSBkZSBmYW1pbGxlIGZpbiAyMDA0LiDvu788L3A+PC9zcGFuPg==
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5MTgiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2ZhYmllbi1mYXNha2Utc2Fpc29uLTIvNTI0NzQzMjgtMS1mcmUtRlIvRmFiaWVuLUZhc2FrZS1zYWlzb24tMl9wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMjM5IiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9IkZhYmllbiBGYXNha2UgKHNhaXNvbiAyKSIgdGl0bGU9IkZhYmllbiBGYXNha2UgKHNhaXNvbiAyKSIgICAvPgogICAgICAgICAgICAKICAgIAogICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+RmFiaWVuIEZhc2FrZSAoc2Fpc29uIDIpPC9zcGFuPjwvc3Ryb25nPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBjbGFzcz0iZGlhcG9fZGVzY3JpcHRpb25faXRlbSI+PHA+Jm5ic3A7SWwgc29ydGkgdW4gc2luZ2xlIGludGl0dWzDqSBQYXMgZGUgdGVtcHMgw6AgcGVyZHJlLiBJbCBkaXJpZ2UgdW4ga2FyYW9rw6kgYXZlYyBzb24gZnLDqHJlIHN1ciBNYWlzb24tTGFmZml0ZS7vu788L3A+PC9zcGFuPg==
  • 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
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5MjIiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL3N0ZXBoYW5pZS1oYW5zZW4tc2Fpc29uLTIvNTI0NzQzNjQtMS1mcmUtRlIvU3RlcGhhbmllLUhhbnNlbi1zYWlzb24tMl9wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMjUwIiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9IlN0w6lwaGFuaWUgSGFuc2VuIChzYWlzb24gMikiIHRpdGxlPSJTdMOpcGhhbmllIEhhbnNlbiAoc2Fpc29uIDIpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9zcGFuPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHN0cm9uZz48c3Bhbj5TdMOpcGhhbmllIEhhbnNlbiAoc2Fpc29uIDIpPC9zcGFuPjwvc3Ryb25nPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBjbGFzcz0iZGlhcG9fZGVzY3JpcHRpb25faXRlbSI+PHA+U3TDqXBoYW5pZSBpbnTDqGdyZSBlbGxlIGF1c3NpIGxhIHRyb3VwZSBTdGFyIENvbGxlY3Rpb24uIEVsbGUgZGV2aWVudCBzcGVha2VyaW5lIHN1ciBMaWJlcnR5IFRWIGV0IGVuc3VpdGUsIGVsbGUgZXN0IGVudHLDqWUgZW4gcG9saXRpcXVlLi4uIFN0w6lwaGFuaWUgYSDDqXTDqSDDqWx1ZSBzdXBwbMOpYW50ZSBlbiAyMDA0IHN1ciBsYSBsaXN0ZSBkdSBNUiDDoCBsYSBSw6lnaW9uIGRlIExpw6hnZS4gU3TDqXBoYW5pZSB0cmF2YWlsbGUgZMOpc29ybWFpcyBlbiB0YW50IHF1ZSBjYWRyZSBjb21tZXJjaWFsZSBkYW5zIHVuZSBlbnRyZXByaXNlIGRlIHPDqWN1cml0w6kuIFBhcmFsbMOobGVtZW50LCBlbGxlIGNvbnRpbnVlIMOgIGNoYW50ZXIgZGFucyAyIGdyb3VwZXMuIO+7vzwvcD48L3NwYW4+
  • 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
  • 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
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5MjgiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL3BoaWxpcHBlLW1pcm8tc2Fpc29uLTIvNTI0NzQ0MTgtMS1mcmUtRlIvUGhpbGlwcGUtTWlyby1zYWlzb24tMl9wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMjMyIiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9IlBoaWxpcHBlIE1pcm8gKHNhaXNvbiAyKSIgdGl0bGU9IlBoaWxpcHBlIE1pcm8gKHNhaXNvbiAyKSIgICAvPgogICAgICAgICAgICAKICAgIAogICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+UGhpbGlwcGUgTWlybyAoc2Fpc29uIDIpPC9zcGFuPjwvc3Ryb25nPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBjbGFzcz0iZGlhcG9fZGVzY3JpcHRpb25faXRlbSI+PHA+RGUgZMOpY2VtYnJlIDIwMDMgw6AgU2VwdGVtYnJlIDIwMDQsIFBoaWxpcHBlIGVzdCBsZSBndWl0YXJpc3RlIGRlIErDqXLDqW15IENow6J0ZWxhaW4gcG91ciBsZXMgdG91cm7DqWVzIGRlIGNlIGRlcm5pZXIuIFBoaWxpcHBlIGRldmllbnQgcGFycmFpbiBkJ3VuZSBhc3NvY2lhdGlvbiBFbmZhbnRzIGRlIGNvZXVyIGV0IHBhcnRpY2lwZSDDoCBkZXMgY29uY2VydHMgcG91ciBjZWxsZS1jaSBlbiBjb21wYWduaWUgZGUgPGEgaHJlZj0iaHR0cDovL3d3dy5wcmVtaWVyZS5mci9TdGFyL01pY2hhZWwtSk9ORVMtODYzOTYiIHRhcmdldD0iX3NlbGYiPk1pY2hhZWwgSm9uZXM8L2E+LCBkZXMgTDXigKYgRW4gMjAxMSwgdGFuZGlzIHF1ZSBQaGlsaXBwZSBjb250aW51ZSBkJ2FycGVudGVyIGxlcyBzY8OobmVzLCBpbCBlbnJlZ2lzdHJlIHVuIGNsaXAgSidhaSBxdWVscXVlcyBhbWlzLCBxdSdpbCBkaWZmdXNlIHN1ciBsZSBuZXQuPC9wPjxwPu+7vzwvcD48L3NwYW4+
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5MzAiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2dlb3JnZXMtYWxhaW4tam9uZXMtc2Fpc29uLTIvNTI0NzQ0MzYtMS1mcmUtRlIvR2Vvcmdlcy1BbGFpbi1Kb25lcy1zYWlzb24tMl9wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMjE3IiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9Ikdlb3JnZXMtQWxhaW4gSm9uZXMgKHNhaXNvbiAyKSIgdGl0bGU9Ikdlb3JnZXMtQWxhaW4gSm9uZXMgKHNhaXNvbiAyKSIgICAvPgogICAgICAgICAgICAKICAgIAogICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxlbT4mY29weTsgSmVhbi1NYXJjIFNVUkVBVTwvZW0+PC9zcGFuPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHN0cm9uZz48c3Bhbj5HZW9yZ2VzLUFsYWluIEpvbmVzIChzYWlzb24gMik8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD48YSBocmVmPSJodHRwOi8vd3d3LnByZW1pZXJlLmZyL1N0YXIvR2Vvcmdlcy1BTEFJTi00MDMzOTgiIHRhcmdldD0iX3NlbGYiPkdlb3JnZXMgQWxhaW48L2E+IHNvcnQgZW4gbWFycyAyMDAzIHNvbiAxZXIgc2luZ2xlLCZuYnNwOyA8aT5FbWJyYXNzZTwvaT4uIEVuIGp1aWxsZXQgMjAwMywgc29ydCA8aT5WaXZyZSBlbiBEYW5nZXI8L2k+LCBzb24gc2Vjb25kIHNpbmdsZS4gTCdhbGJ1bSBOZXcgSmVyc2V5IHNvcnRpcmEgYmllbiBlbiBvY3RvYnJlIDIwMDUsIHNvaXQgdW4gYW4gcGx1cyB0YXJkIHF1ZSBwcsOpdnUuIElsIGNvbnRpbnVlIHNvbiBib25ob21tZSBkZSBjaGVtaW4gZXQgb3JnYW5pc2UgcXVlbHF1ZXMgY29uY2VydHMuPC9wPjwvc3Bhbj4=
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ5MzIiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2VtbWEtZGF1bWFzLXNhaXNvbi0yLzUyNDc0NDU0LTEtZnJlLUZSL0VtbWEtRGF1bWFzLXNhaXNvbi0yX3BvcnRyYWl0X3c4NTguanBnIiB3aWR0aD0iODU4IiBoZWlnaHQ9IjEyOTYiICBzdHlsZT0iYm9yZGVyOiAwcHggIDsiIGFsdD0iRW1tYSBEYXVtYXMgKHNhaXNvbiAyKSIgdGl0bGU9IkVtbWEgRGF1bWFzIChzYWlzb24gMikiICAgLz4KICAgICAgICAgICAgCiAgICAKICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8ZW0+JmNvcHk7IFNVUkVBVSBKZWFuLU1hcmM8L2VtPjwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+RW1tYSBEYXVtYXMgKHNhaXNvbiAyKTwvc3Bhbj48L3N0cm9uZz4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHNwYW4gY2xhc3M9ImRpYXBvX2Rlc2NyaXB0aW9uX2l0ZW0iPjxwPkVuIGbDqXZyaWVyIDIwMDMgc29ydCBzb24gcHJlbWllciBzaW5nbGUgQXUgam91ciBsZSBqb3VyIGRvbnQgZWxsZSBlc3QgbCdhdXRldXItY29tcG9zaXRldXIgcXVpIHMnw6ljb3VsZSDDoCAyMDAgMDAwIGV4ZW1wbGFpcmVzLiBFbiBqdWlsbGV0IGRlIGxhIG3Dqm1lIGFubsOpZSwgdW4gbGl2cmUgc3VyIHNvbiBwYXJjb3VycywgPGk+QXUgam91ciBsZSBqb3VyPC9pPiBkZSBHw6lyYWxkIEJhc3NlcG9ydGUsIHBhcmHDrnQuIEMnZXN0IGxlIDIgZMOpY2VtYnJlIHF1ZSBzb24gcHJlbWllciBhbGJ1bSwgPGk+TGUgU2F1dCBkZSBsJ2FuZ2U8L2k+LCB2b2l0IGxlIGpvdXIuIFNvbiBub3V2ZWwgYWxidW0gcydpbnRpdHVsZSA8aT5FZmZldHMgc2Vjb25kYWlyZXM8L2k+LiBTb24gdHJvaXNpw6htZSBhbGJ1bSwgPGk+TGUgY2hlbWluIGRlIGxhIG1haXNvbjwvaT4sIHNvcnQgZW4gbm92ZW1icmUgMjAwOC4gRW4gbWFpIDIwMTAsIEVtbWEgcXVpdHRlIFVuaXZlcnNhbCBldCBwdWJsaWUgdW4gRS5QLiBkaWdpdGFsLiBFbiAyMDExLCA8YSBocmVmPSJodHRwOi8vd3d3LnByZW1pZXJlLmZyL1N0YXIvRW1tYS1EQVVNQVMtOTEyODUiIHRhcmdldD0iX3NlbGYiPkVtbWEgRGF1bWFzPC9hPiBhIMOpZ2FsZW1lbnQgw6l0w6kgY29udGFjdMOpIGFmaW4gZGUgcmVwcsOpc2VudGVyIGxhIEZyYW5jZSDDoCBsJ0V1cm92aXNpb24uPC9wPjwvc3Bhbj4=
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ4NjYiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL21vcmdhbm5lLW1hdGlzLXNhaXNvbi0zLzUyNDczNzkyLTEtZnJlLUZSL01vcmdhbm5lLU1hdGlzLXNhaXNvbi0zX3BvcnRyYWl0X3c4NTguanBnIiB3aWR0aD0iODU4IiBoZWlnaHQ9IjEyODAiICBzdHlsZT0iYm9yZGVyOiAwcHggIDsiIGFsdD0iTW9yZ2FubmUgTWF0aXMgKHNhaXNvbiAzKSIgdGl0bGU9Ik1vcmdhbm5lIE1hdGlzIChzYWlzb24gMykiICAgLz4KICAgICAgICAgICAgCiAgICAKICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8ZW0+JmNvcHk7IENIT0dOQVJEIEV0aWVubmUgLyBTVVJFQVUgSmVhbi1NPC9lbT48L3NwYW4+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3Ryb25nPjxzcGFuPk1vcmdhbm5lIE1hdGlzIChzYWlzb24gMyk8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD5Nb3JnYW5uZSBmb25kZSBEdWVsIFByb2QsIHNhIHNvY2nDqXTDqSBkZSBwcm9kdWN0aW9uLCBldCB0cmF2YWlsbGUgcGVuZGFudCBwbHVzIGQndW5lIGFubsOpZSDDoCBsJ8OpY3JpdHVyZSBkZSA8aT5GaWxsZSBkZSBMJ8OocmU8L2k+IHF1aSBzb3J0IGNvdXJhbnQgMjAwNi4gRWxsZSBlc3Qgw6AgbCdhZmZpY2hlIGRlIGxhIGNvbcOpZGllIG11c2ljYWxlIDxpPkRlIFBhcmlzIMOgIEJyb2Fkd2F5PC9pPiBkZXB1aXMgb2N0b2JyZSAyMDExIGF1IHRow6nDonRyZSBMZSBUZW1wbGUgZGUgUGFyaXMuPC9wPjwvc3Bhbj4=
  • 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
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ4NzAiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL21hcmpvcmllLWNvbmRvcmlzLXNhaXNvbi0zLzUyNDczODI4LTEtZnJlLUZSL01hcmpvcmllLUNvbmRvcmlzLXNhaXNvbi0zX3BvcnRyYWl0X3c4NTguanBnIiB3aWR0aD0iODU4IiBoZWlnaHQ9IjEyODAiICBzdHlsZT0iYm9yZGVyOiAwcHggIDsiIGFsdD0iTWFyam9yaWUgQ29uZG9yaXMgKHNhaXNvbiAzKSIgdGl0bGU9Ik1hcmpvcmllIENvbmRvcmlzIChzYWlzb24gMykiICAgLz4KICAgICAgICAgICAgCiAgICAKICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8ZW0+JmNvcHk7IENIT0dOQVJEIEV0aWVubmUgLyBTVVJFQVUgSmVhbi1NPC9lbT48L3NwYW4+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3Ryb25nPjxzcGFuPk1hcmpvcmllIENvbmRvcmlzIChzYWlzb24gMyk8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD5NYXJqb3JpZSB0cmF2YWlsbGUgbGUgY2hhbnQsIGwnaW50ZXJwcsOpdGF0aW9uIGV0IGxhIHRlY2huaXF1ZSBkYW5zIGwnw4ljb2xlIGRlIFJpY2hhcmQgQ3Jvc3MuIEVsbGUgcydlc3QgbWlzZSDDoCBsJ8OpY3JpdHVyZSwgZXQgYSBhaW5zaSBzaWduw6kgdG91cyBsZXMgdGV4dGVzIGRlcyBjaGFuc29ucyBzdXIgbGVzcXVlbGxlcyBlbGxlIHRyYXZhaWxsZS4gTWFyam9yaWUgZGV2aWVudCBNYXJqZWUgZXQgZW4gbWFycyAyMDA3LCBlbGxlIHNvcnQgdW4gc2luZ2xlIEF1dG91ciBkZSB0b2kgcXVpIHBhc3NlIGluYXBlcsOndS4gQWN0dWVsbGVtZW50LCBlbGxlIG1ldCDDoCBwcm9maXQgc2VzIMOpdHVkZXMgZGFucyBkZSBncmFuZGVzIMOpY29sZXMgZGUgY29tbWVyY2UgZXQgdHJhdmFpbGxlIGNvbW1lIENoZWYgZGUgcHJvZHVpdCBtYXJvcXVpbmVyaWUgY2hleiBMb3VpcyBWdWl0dG9uLjwvcD48L3NwYW4+
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ4NjQiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2FubmUtdGhpYmF1bHQtc2Fpc29uLTMvNTI0NzM3NzQtMS1mcmUtRlIvQW5uZS1UaGliYXVsdC1zYWlzb24tM19wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMjc3IiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9IkFubmUgVGhpYmF1bHQgKHNhaXNvbiAzKSIgdGl0bGU9IkFubmUgVGhpYmF1bHQgKHNhaXNvbiAzKSIgICAvPgogICAgICAgICAgICAKICAgIAogICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxlbT4mY29weTsgQ0hPR05BUkQgRXRpZW5uZSAvIFNVUkVBVSBKZWFuLU08L2VtPjwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+QW5uZSBUaGliYXVsdCAoc2Fpc29uIDMpPC9zcGFuPjwvc3Ryb25nPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBjbGFzcz0iZGlhcG9fZGVzY3JpcHRpb25faXRlbSI+PHA+QW5uZSByZXByZW5kIHNlcyDDqXR1ZGVzIGV0IHBhc3NlIGxlIGRpcGzDtG1lIGRlIFNjaWVuY2VzIFBvIMOgIFBhcmlzLiBFbGxlIGVuIHByb2ZpdGUgw6lnYWxlbWVudCBwb3VyIHRyYXZhaWxsZXIgYXZlYyBkZXMgY29tcG9zaXRldXJzIHN1ciBzZXMgdGV4dGVzIHBlcnNvPC9wPjxwPkFwcsOocyBxdWVscXVlcyBnYWzDqHJlcyBldCB1bmUgcMOpcmlvZGUgZGUgcmVjdWwgZmFjZSDDoCBsYSBtdXNpcXVlLCBBbm5lIGEgZW5zdWl0ZSB0cm91dsOpIHVuIHZyYWkgYm91bG90IGVuIGZyZWUgbGFuY2UgZGFucyBsYSBjb21tdW5pY2F0aW9uLiBBbm5lIGEgYWxvcnMgcmVjb21tZW5jw6kgw6AgZmFpcmUgZGUgbGEgbXVzaXF1ZS4gRWxsZSBhIGpvdcOpZSBkYW5zIHVuIGdyb3VwZSBkZSBoaXAtaG9wLCBUcmFmaWthbmRhbS4gRW4gcGFyYWxsw6hsZSwgQW5uZSBhIGNyw6nDqWUgdW5lIE9ORyBwb3VyIGFpZGVyIMOgIGxhIHNjb2xhcmlzYXRpb24gZGVzIGVuZmFudHMgZXQgw6AgbCdhbHBoYWLDqXRpc2F0aW9uIGRlcyBhZHVsdGVzIGF1IELDqW5pbi48L3A+PC9zcGFuPg==
  • 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
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ4NzQiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL21pY2hhZWwtc2FwaWVuY2Utc2Fpc29uLTMvNTI0NzM4NjQtMS1mcmUtRlIvTWljaGFlbC1TYXBpZW5jZS1zYWlzb24tM19wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMjgwIiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9Ik1pY2hhw6tsIFNhcGllbmNlIChzYWlzb24gMykiIHRpdGxlPSJNaWNoYcOrbCBTYXBpZW5jZSAoc2Fpc29uIDMpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGVtPiZjb3B5OyBDSE9HTkFSRCBFdGllbm5lIC8gU1VSRUFVIEplYW4tTTwvZW0+PC9zcGFuPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHN0cm9uZz48c3Bhbj5NaWNoYcOrbCBTYXBpZW5jZSAoc2Fpc29uIDMpPC9zcGFuPjwvc3Ryb25nPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBjbGFzcz0iZGlhcG9fZGVzY3JpcHRpb25faXRlbSI+PHA+SWwgdHJhdmFpbGxlIGF2ZWMgPGEgaHJlZj0iaHR0cDovL3d3dy5wcmVtaWVyZS5mci9TdGFyL09zY2FyLVNpc3RvLTIxMjAyMTAiIHRhcmdldD0iX3NlbGYiPk9zY2FyIFNpc3RvPC9hPiwgZXQgZmFpdCBwbHVzaWV1cnMgY29uY2VydHMgw6AgTWFkYWdhc2NhciBjZSBxdWkgbHVpIHBlcm1ldCBkZSBnYWduZXIgdW4gcGV1IGQnYXJnZW50LiBJbCBmYWl0IGF1c3NpIHVuIHBldSBkZSBtYW5uZXF1aW5hdC4gRW4gMjAwNCwgTWljaGHDq2wgZMOpZnJhaWUgbGEgY2hyb25pcXVlIGVuIMOpdGFudCBjaXTDqSAtIGNvbW1lIHNpbXBsZSB0w6ltb2luIC0gZGFucyB1bmUgYWZmYWlyZSBkZSBwaG90b3Mgw6lyb3RpcXVlcyBldCBkZSB0cmFmaWMgZGUgY29jYcOvbmUuIElsIHNlcmFpdCBhdWpvdXJkJ2h1aSBTdGV3YXJ0IHBvdXIgbGEgRW1pcmF0ZXMgQWlybGluZXMuPC9wPjwvc3Bhbj4=
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ4NzYiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2ljYXJvLWpvcmdlLXNhaXNvbi0zLzUyNDczODgyLTEtZnJlLUZSL0ljYXJvLUpvcmdlLXNhaXNvbi0zX3BvcnRyYWl0X3c4NTguanBnIiB3aWR0aD0iODU4IiBoZWlnaHQ9IjE3ODciICBzdHlsZT0iYm9yZGVyOiAwcHggIDsiIGFsdD0iSWNhcm8gSm9yZ2UgKHNhaXNvbiAzKSIgdGl0bGU9IkljYXJvIEpvcmdlIChzYWlzb24gMykiICAgLz4KICAgICAgICAgICAgCiAgICAKICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8ZW0+JmNvcHk7IENIT0dOQVJEIEV0aWVubmUgLyBTVVJFQVUgSmVhbi1NPC9lbT48L3NwYW4+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3Ryb25nPjxzcGFuPkljYXJvIEpvcmdlIChzYWlzb24gMyk8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD5JY2FybyB0cmF2YWlsbGUgcG91ciBkaWZmw6lyZW50cyBtw6lkaWFzIFN1aXNzZSBjb21tZSBDaHJvbmlxdWV1ci4gQSAyNSBhbnMgSWNhcm8gc2VtYmxlIGF2b2lyIGTDqXBsb3nDqSBzZXMgYWlsZXMgZXQgcHJvZHVpdCBzb24gcHJlbWllciBzaW5nbGUgPGk+U29ycm93PC9pPi4gSWwgYSDDqWNyaXQgdW4gcm9tYW4gZG9udCBsYSBkYXRlIGRlIHNvcnRpZSByZXN0ZSDDoCBjb25maXJtZXIuIO+7vzwvcD48L3NwYW4+
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ4NzgiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL3JvbWFpbi13eWxzb24tc2Fpc29uLTMvNTI0NzM5MDAtMS1mcmUtRlIvUm9tYWluLVd5bHNvbi1zYWlzb24tM19wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMjgwIiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9IlJvbWFpbiBXeWxzb24gKHNhaXNvbiAzKSIgdGl0bGU9IlJvbWFpbiBXeWxzb24gKHNhaXNvbiAzKSIgICAvPgogICAgICAgICAgICAKICAgIAogICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxlbT4mY29weTsgQ0hPR05BUkQgRXRpZW5uZSAvIFNVUkVBVSBKZWFuLU08L2VtPjwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+Um9tYWluIFd5bHNvbiAoc2Fpc29uIDMpPC9zcGFuPjwvc3Ryb25nPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBjbGFzcz0iZGlhcG9fZGVzY3JpcHRpb25faXRlbSI+PHA+SWwgcmVqb2ludCDDqWdhbGVtZW50IGxlIGdyb3VwZSBQcmVtaXguIEEgbGEgcmVudHLDqWUgMjAwOSwgUm9tYWluIHMnaW5zY3JpdCBzdXIgbGUgc2l0ZSBBa2EgTXVzaWMgZGFucyBsJ2VzcG9pciBkZSBzb3J0aXIgZW5maW4gc29uIHByZW1pZXIgYWxidW0gcsOpYWxpc8OpIHBhciBzb24gZXggY29tcMOocmUgRWRvdWFyZCBBbGdheW9uLjwvcD48L3NwYW4+
  • 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
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ4ODIiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL3N0ZXBoYW5pZS1kLWFsbWEtc2Fpc29uLTMvNTI0NzM5MzYtMS1mcmUtRlIvU3RlcGhhbmllLUQtQWxtYS1zYWlzb24tM19wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMjgzIiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9IlN0w6lwaGFuaWUgRCdBbG1hIChzYWlzb24gMykiIHRpdGxlPSJTdMOpcGhhbmllIEQnQWxtYSAoc2Fpc29uIDMpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGVtPiZjb3B5OyBDSE9HTkFSRCBFdGllbm5lIC8gU1VSRUFVIEplYW4tTTwvZW0+PC9zcGFuPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHN0cm9uZz48c3Bhbj5TdMOpcGhhbmllIEQnQWxtYSAoc2Fpc29uIDMpPC9zcGFuPjwvc3Ryb25nPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBjbGFzcz0iZGlhcG9fZGVzY3JpcHRpb25faXRlbSI+PHA+QSBsJ2F1dG9tbmUgMjAwNCwgU3TDqXBoYW5pZSBmYWl0IHVuZSBwcmVzdGF0aW9uIHJlbWFycXXDqWUgZGFucyB1biBkZXMgw6lwaXNvZGVzIGRlIGxhIHPDqXJpZSA8aT48YSBocmVmPSJodHRwOi8vc2VyaWVzLXR2LnByZW1pZXJlLmZyL1BlcmUtZXQtTWFpcmUtMTU5ODE1MiIgdGFyZ2V0PSJfc2VsZiI+UMOocmUgZXQgTWFpcmU8L2E+PC9pPiBhdXggY8O0dMOpcyBkZSBEYW5pZWwgUmlhbGV0IGV0IENocmlzdGlhbiBSYXV0aCBkaWZmdXPDqSBzdXIgVEYxLiBFbGxlIGEgZW5jaGHDrm7DqWUgbGVzIGNhc3RpbmdzIHRvdXQgZW4gY29udGludWFudCBkJ8OpbGFyZ2lyIHNlcyBjb21ww6l0ZW5jZXMgZW4gY29udGludWFudCBkZSBwcmVuZHJlIHNlcyBjb3Vycy4gU3TDqXBoYW5pZSBhIG9idGVudSBsZSByw7RsZSBkZSBCcmlkZ2V0IGRhbnMgdW5lIGNvbcOpZGllIG11c2ljYWxlIGF1eCBjb3VsZXVycyBjZWx0ZXMuIEVsbGUgcG91cnN1aXQgc2EgY2FycmnDqHJlIGF1IHRow6nDonRyZS4g77u/PC9wPjwvc3Bhbj4=
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ4ODQiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2FtaW5hLWJlbm91bm5pLXNhaXNvbi0zLzUyNDczOTU0LTEtZnJlLUZSL0FtaW5hLUJlbm91bm5pLXNhaXNvbi0zX3BvcnRyYWl0X3c4NTguanBnIiB3aWR0aD0iODU4IiBoZWlnaHQ9IjU2NiIgIHN0eWxlPSJib3JkZXI6IDBweCAgOyIgYWx0PSJBbWluYSBCZW5vdW5uaSAoc2Fpc29uIDMpIiB0aXRsZT0iQW1pbmEgQmVub3VubmkgKHNhaXNvbiAzKSIgICAvPgogICAgICAgICAgICAKICAgIAogICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxlbT4mY29weTsgQ0hPR05BUkQgRXRpZW5uZSAvIFNVUkVBVSBKZWFuLU08L2VtPjwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+QW1pbmEgQmVub3VubmkgKHNhaXNvbiAzKTwvc3Bhbj48L3N0cm9uZz4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHNwYW4gY2xhc3M9ImRpYXBvX2Rlc2NyaXB0aW9uX2l0ZW0iPjxwPkFtaW5hIGVzdCBlbnRyw6llIGRhbnMgdW4gZ3JhbmQgb3JjaGVzdHJlIGV0IHkgY2hhbnRlIHNlcyBwcm9wcmVzIGNvbXBvc2l0aW9ucy4gQW1pbmEgcG9zZSBzYSB2b2l4IGVuIG1hcnMgMjAwNyBzdXIgbGUgdGl0cmUgPGk+T8O5IGVzLXR1PyA8L2k+ZGFucyBsZXMgY2hvZXVycyBwb3VyIEFudGhvbnkgRmFiaWVuLCBqZXVuZSBhcnRpc3RlIGZyYW7Dp2FpcyBldCBhc3N1cmUgbGVzIHByZW1pw6hyZXMgcGFydGllcyBkJ2FydGlzdGVzIHRlbHMgcXVlIDxhIGhyZWY9Imh0dHA6Ly93d3cucHJlbWllcmUuZnIvU3Rhci9IZXJiZXJ0LUxlb25hcmQtMjAyNzM0NSIgdGFyZ2V0PSJfc2VsZiI+SGVyYmVydCBMw6lvbmFyZDwvYT4uIDwvcD48L3NwYW4+
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ4ODYiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL3BhdHhpLWdhcmF0LXNhaXNvbi0zLzUyNDczOTcyLTEtZnJlLUZSL1BhdHhpLUdhcmF0LXNhaXNvbi0zX3BvcnRyYWl0X3c4NTguanBnIiB3aWR0aD0iODU4IiBoZWlnaHQ9IjEyODAiICBzdHlsZT0iYm9yZGVyOiAwcHggIDsiIGFsdD0iUGF0eGkgR2FyYXQgKHNhaXNvbiAzKSIgdGl0bGU9IlBhdHhpIEdhcmF0IChzYWlzb24gMykiICAgLz4KICAgICAgICAgICAgCiAgICAKICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8ZW0+JmNvcHk7IENIT0dOQVJEIEV0aWVubmUgLyBTVVJFQVUgSmVhbi1NPC9lbT48L3NwYW4+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3Ryb25nPjxzcGFuPlBhdHhpIEdhcmF0IChzYWlzb24gMyk8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD5FbiBtYXJzIDIwMDQsIGlsIHNvcnQgc29uIHByZW1pZXIgc2luZ2xlLCA8aT7DgCBsJ2FuZ2xhaXNlPC9pPi4gU29uIHByZW1pZXIgYWxidW0sIHRpdHLDqSA8aT5TJ2VtYnJhc3NlcjwvaT4gc29ydCBlbiBhb8O7dCAyMDA2LiBEw6lidXQgMjAwOCwgaWwgYW5ub25jZSBsYSBwcsOpcGFyYXRpb24gZCd1biBzZWNvbmQgYWxidW0gcG91ciBsJ2F1dG9tbmUuIFNvbiBub3V2ZWwgYWxidW0gPGk+QW1vdXIgQ2FyYWJpbmU8L2k+IGVzdCBzb3J0aSBlbiBtYWkgMjAxMC4gSWwgcmV2aWVudCBkYW5zIGxlcyBiYWNzIGZpbiAyMDExIGF2ZWMgdW4gRVAgLiBQb3VyIGxlIGTDqWZlbmRyZSwgPGk+aWwgYSBjaG9pc2kgbGUgdGl0cmUgUXVpdHRlciBsYSBGcmFuY2U8L2k+LjwvcD48L3NwYW4+
  • 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
  • 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
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ4OTIiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL3BpZXJyZS1uZXN0YS1zYWlzb24tMy81MjQ3NDAyNi0xLWZyZS1GUi9QaWVycmUtTmVzdGEtc2Fpc29uLTNfcG9ydHJhaXRfdzg1OC5qcGciIHdpZHRoPSI4NTgiIGhlaWdodD0iMTI4MCIgIHN0eWxlPSJib3JkZXI6IDBweCAgOyIgYWx0PSJQaWVycmUgTmVzdGEgKHNhaXNvbiAzKSIgdGl0bGU9IlBpZXJyZSBOZXN0YSAoc2Fpc29uIDMpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGVtPiZjb3B5OyBDSE9HTkFSRCBFdGllbm5lIC8gU1VSRUFVIEplYW4tTTwvZW0+PC9zcGFuPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHN0cm9uZz48c3Bhbj5QaWVycmUgTmVzdGEgKHNhaXNvbiAzKTwvc3Bhbj48L3N0cm9uZz4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHNwYW4gY2xhc3M9ImRpYXBvX2Rlc2NyaXB0aW9uX2l0ZW0iPjxwPkTDqWNlbWJyZSAyMDAzLCBsZSBncm91cGUgUHLDqW1peCBjb21wb3PDqSBkZSBQaWVycmUsIFJvbWFpbiBldCBFZG91YXJkIHMnZW5mZXJtZSBkYW5zIGxhIGNoYW1icmUgMTUxMiBwb3VyIMOpY3JpcmUgdW4gYWxidW0uIExlIGdyb3VwZSBzZSBzw6lwYXJlIGVuIDIwMDUuIFBpZXJyZSBkw6ljaWRlIGRlIHByZW5kcmUgdW4gbm9tIGQnYXJ0aXN0ZSBldCBkZSBkZXZlbmlyIFBpZXJyZS1Mb3VwLiBJbCB0cmF2YWlsbGUgc3VyIHVuIGFsYnVtLjwvcD48L3NwYW4+
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ4OTQiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL3ZhbGVyaWUtZGVuaXotc2Fpc29uLTMvNTI0NzQwNDQtMS1mcmUtRlIvVmFsZXJpZS1EZW5pei1zYWlzb24tM19wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMjgwIiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9IlZhbMOpcmllIERlbml6IChzYWlzb24gMykiIHRpdGxlPSJWYWzDqXJpZSBEZW5peiAoc2Fpc29uIDMpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGVtPiZjb3B5OyBDSE9HTkFSRCBFdGllbm5lIC8gU1VSRUFVIEplYW4tTTwvZW0+PC9zcGFuPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHN0cm9uZz48c3Bhbj5WYWzDqXJpZSBEZW5peiAoc2Fpc29uIDMpPC9zcGFuPjwvc3Ryb25nPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBjbGFzcz0iZGlhcG9fZGVzY3JpcHRpb25faXRlbSI+PHA+RWxsZSBhIHJlcHJpcyBzZXMgw6l0dWRlcyBwYXIgY29ycmVzcG9uZGFuY2UgZXQgYSBpbnTDqWdyw6kgdW5lIMOpY29sZSBkZSBtdXNpcXVlIMOgIFBhcmlzLiBGaW4gMjAwOCwgVmFsw6lyaWUgbW9udGUgbGUgY29sbGVjdGlmIEFzaGNvbWJlIHRyYXZhaWxsYW50IHN1ciB1biBhbGJ1bSBldCBkZXMgcHJvamV0cyBsaXZlLiBTZXB0ZW1icmUgMjAxMSwgVmFsw6lyaWUgZGl0IGFkaWV1IMOgIEFzaGNvbWJlIGV0IGludMOoZ3JlIERpY2UuPC9wPjwvc3Bhbj4=
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ0MzgiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2hhcmxlbS1oYXJsLXNhaXNvbi00LzUyNDY4OTQ4LTEtZnJlLUZSL0hhcmxlbS1IYXJsLXNhaXNvbi00X3BvcnRyYWl0X3c4NTguanBnIiB3aWR0aD0iODU4IiBoZWlnaHQ9IjEyODAiICBzdHlsZT0iYm9yZGVyOiAwcHggIDsiIGFsdD0iSGFybGVtIEhhcmwgKHNhaXNvbiA0KSIgdGl0bGU9IkhhcmxlbSBIYXJsIChzYWlzb24gNCkiICAgLz4KICAgICAgICAgICAgCiAgICAKICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8ZW0+JmNvcHk7IENIT0dOQVJEIEV0aWVubmUgLCBTVVJFQVUgSmVhbi1NPC9lbT48L3NwYW4+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3Ryb25nPjxzcGFuPkhhcmxlbSBIYXJsIChzYWlzb24gNCk8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD5JbCBkw6ljaWRlIGRlIGNyw6llciBzb24gcHJvcHJlIGxhYmVsIGV0IGRlIGfDqXJlciBzZXMgcHJvcHJlcyBhZmZhaXJlcy4gTGUgbGFiZWwgMTExMSBNVVNJQyBzZSBtZXQgZW4gcGxhY2UgcGV0aXQgw6AgcGV0aXQgZXQgbCdhbGJ1bSBjb21tZW5jZSDDoCBwcmVuZHJlIHVuZSB0b3V0ZSBhdXRyZSB0b3VybnVyZS4gTCdvYmplY3RpZiBlc3QgZCfDqnRyZSBlbiB0b3RhbGUgYXV0b25vbWllLiBMZSB0aXRyZSA8aT5Nb3J0ZWwgPC9pPmVzdCBlbnJlZ2lzdHLDqSBkYW5zIGxldXIgc3R1ZGlvIGV0IGxlIGNsaXAgcydlbiBzdWl0IHBldSBkZSB0ZW1wcyBhcHLDqHMuIEVuIHBhcmFsbMOobGUgw6AgdG91dCBjZWxhLCBIYXJsZW0gcydhZmZhaXJlIMOgIGxhIG1pc2UgZW4gcGxhY2UgZCd1bmUgdG91cm7DqWUgbmF0aW9uYWxlIGFwcGVsw6llIEhpcCBIb3AgPGk+Q29uc2NpZW5jZSBUb3VyPC9pPi4gSWwgYSDDqWNyaXQgPGk+TGVzIGZsZXVycyBkZSBsJ8OpdGVybml0w6k8L2k+IGVuIGhvbW1hZ2Ugw6Agc29uIGFtaSBHcsOpZ29yeSBMZW1hcmNoYWwuIElsIHRyYXZhaWxsZSBhY3R1ZWxsZW1lbnQgdG91am91cnMgc3VyIHNvbiBhbGJ1bS4gPC9wPjxwPu+7vzwvcD48L3NwYW4+
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ0NDAiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL3NhbmR5LWZyYW5jb2lzLXNhaXNvbi00LzUyNDY4OTY2LTEtZnJlLUZSL1NhbmR5LUZyYW5jb2lzLXNhaXNvbi00X3BvcnRyYWl0X3c4NTguanBnIiB3aWR0aD0iODU4IiBoZWlnaHQ9IjEyODAiICBzdHlsZT0iYm9yZGVyOiAwcHggIDsiIGFsdD0iU2FuZHkgRnJhbsOnb2lzIChzYWlzb24gNCkiIHRpdGxlPSJTYW5keSBGcmFuw6dvaXMgKHNhaXNvbiA0KSIgICAvPgogICAgICAgICAgICAKICAgIAogICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxlbT4mY29weTsgQ0hPR05BUkQgRXRpZW5uZSwgU1VSRUFVIEplYW4tTWE8L2VtPjwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+U2FuZHkgRnJhbsOnb2lzIChzYWlzb24gNCk8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD5BcHLDqHMgbGEgdG91cm7DqWUgU3RhciBBY2FkZW15LCBTYW5keSBlc3QgZGFuc2V1c2Ugc3VyIHBsdXNpZXVycyDDqW1pc3Npb25zIGRlIHTDqWzDqSBlbiAyMDA2LiBFbiBmaW4gZCdhbm7DqWUsIFNhbmR5IGZhaXQgdW5lIHBhcnRpY2lwYXRpb24gYXUgY2xpcCA8aT5BbGwgYXJvdW5kIHRoZSBXb3JsZCA8L2k+YXZlYyA8YSBocmVmPSJodHRwOi8vd3d3LnByZW1pZXJlLmZyL1N0YXIvTGlvbmVsLVJpY2hpZS0yMTA3NTc4IiB0YXJnZXQ9Il9zZWxmIj5MaW9uZWwgUmljaGllPC9hPiBldCA8YSBocmVmPSJodHRwOi8vd3d3LnByZW1pZXJlLmZyL1N0YXIvQm9iLVNpbmNsYXItMTgyMzQyNyIgdGFyZ2V0PSJfc2VsZiI+Qm9iIFNpbmNsYXI8L2E+Lu+7vzwvcD48L3NwYW4+
  • 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
  • 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
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ0NDQiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2pvaG4tZXl6ZW4tc2Fpc29uLTQvNTI0NjkwMDItMS1mcmUtRlIvSm9obi1FeXplbi1zYWlzb24tNF9wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMjgwIiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9IkpvaG4gRXl6ZW4gKHNhaXNvbiA0KSIgdGl0bGU9IkpvaG4gRXl6ZW4gKHNhaXNvbiA0KSIgICAvPgogICAgICAgICAgICAKICAgIAogICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxlbT4mY29weTsgQ0hPR05BUkQgRXRpZW5uZSwgU1VSRUFVIEplYW4tTWE8L2VtPjwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+Sm9obiBFeXplbiAoc2Fpc29uIDQpPC9zcGFuPjwvc3Ryb25nPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBjbGFzcz0iZGlhcG9fZGVzY3JpcHRpb25faXRlbSI+PHA+RW4gZsOpdnJpZXIgMjAwNSwgaWwgc29ydCBzb24gcHJlbWllciBzaW5nbGUgaW50aXR1bMOpIFNhbGUgdGVtcHMuIEpvaG4gcmV0cm91dmUgc29uIGdyb3VwZSBFeXplbiwgYXZlYyBxdWkgaWwgZW5yZWdpc3RyZSBzb24gMWVyIGFsYnVtLCB0b3V0IGVuIGVuY2hhw65uYW50IGxlcyBjb25jZXJ0cy4gRW4gMjAwOCBpbCBpbnTDqGdyZSBsYSBjb21wYWduaWUgTWlyYW5kYS4gRW4gSnVpbiAyMDA4LCBKb2huIGNyw6llIHNvbiBub3V2ZWF1IGdyb3VwZSBVbnRhaW1lZCwgYXZlYyBsZXF1ZWwgaWwgcHLDqXBhcmUgdW4gYWxidW0gRnVuay1Sb2NrLiBJbCB0aWVudCDDqWdhbGVtZW50IGxlIHLDtGxlIGRlIE1lcmN1dGlvIGRhbnMgbGEgQ29tw6lkaWUgTXVzaWNhbGUgZGUgR8OpcmFyZCBQcmVzZ3VydmljIDxpPjxhIGhyZWY9Imh0dHA6Ly9zcGVjdGFjbGVzLnByZW1pZXJlLmZyL1NhbGxlLWRlLVNwZWN0YWNsZS9TcGVjdGFjbGUvUm9tZW8tRXQtSnVsaWV0dGUtMTg3ODA0NSIgdGFyZ2V0PSJfc2VsZiI+Um9tw6lvIGV0IEp1bGlldHRlPC9hPjwvaT4uIDwvcD48cD7vu788L3A+PC9zcGFuPg==
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ0NDYiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2dhdXRoaWVyLXJvdWJpY2hvdS1zYWlzb24tNC81MjQ2OTAyMC0xLWZyZS1GUi9HYXV0aGllci1Sb3ViaWNob3Utc2Fpc29uLTRfcG9ydHJhaXRfdzg1OC5qcGciIHdpZHRoPSI4NTgiIGhlaWdodD0iMTA1NiIgIHN0eWxlPSJib3JkZXI6IDBweCAgOyIgYWx0PSJHYXV0aGllciBSb3ViaWNob3UgKHNhaXNvbiA0KSIgdGl0bGU9IkdhdXRoaWVyIFJvdWJpY2hvdSAoc2Fpc29uIDQpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9zcGFuPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHN0cm9uZz48c3Bhbj5HYXV0aGllciBSb3ViaWNob3UgKHNhaXNvbiA0KTwvc3Bhbj48L3N0cm9uZz4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHNwYW4gY2xhc3M9ImRpYXBvX2Rlc2NyaXB0aW9uX2l0ZW0iPjxwPklsIHBhcnQgZW4gQ2hpbmUgb8O5IGlsIGVuY2hhw65uZSBsZXMgcGV0aXRzIGJvdWxvdHMgZXQgcGVyZmVjdGlvbm5lIHNvbiBjaGlub2lzLiBJbCBvcmdhbmlzZSBkZXMgcGV0aXRzIGNvbmNlcnRzIGzDoC1iYXMuIEzDoCBiYXMsIGlsIGRldmllbnQgbGUgY2hhbnRldXIgZXQgZ3VpdGFyaXN0ZSBkdSBncm91cGUgU3dpbmcgRHluYXN0eS4gRW4gbm92ZW1icmUgMjAwOCwgR2F1dGhpZXIgY3LDqWUgVGhlIExpb25zIG9mIFB1eGkgYXZlYyBkZXV4IG11c2ljaWVucyBmcmFuw6dhaXMsIHRyb2lzIG1hdXJpY2llbnMgZXQgdW4gY2hpbm9pcy4gSWwgYSDDqXTDqSDDqWx1IG1laWxsZXVyIGdyb3VwZSBkZSBTaGFuZ2hhaS4mbmJzcDsgSWwgZGV2aWVudCB1bmUgdsOpcml0YWJsZSBzdGFyIGVuIENoaW5lIG/DuSBpbCBlbmNoYcOubmUgbGVzIHN1Y2PDqHMgZXQgbGVzIHBsYXRlYXV4IFRWLiZuYnNwOyDvu788L3A+PC9zcGFuPg==
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ0NDgiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL21vcmdhbi1hdWdlci1zYWlzb24tNC81MjQ2OTAzOC0xLWZyZS1GUi9Nb3JnYW4tQXVnZXItc2Fpc29uLTRfcG9ydHJhaXRfdzg1OC5qcGciIHdpZHRoPSI4NTgiIGhlaWdodD0iMTExNyIgIHN0eWxlPSJib3JkZXI6IDBweCAgOyIgYWx0PSJNb3JnYW4gQXVnZXIgKHNhaXNvbiA0KSIgdGl0bGU9Ik1vcmdhbiBBdWdlciAoc2Fpc29uIDQpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9zcGFuPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHN0cm9uZz48c3Bhbj5Nb3JnYW4gQXVnZXIgKHNhaXNvbiA0KTwvc3Bhbj48L3N0cm9uZz4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHNwYW4gY2xhc3M9ImRpYXBvX2Rlc2NyaXB0aW9uX2l0ZW0iPjxwPiZuYnNwO0FwcsOocyB1biBzw6lqb3VyIGF1eCBFdGF0cy1VbmlzIGwnw6l0w6kgMjAwNSwgaWwgYSBldSBkZXMgcHJvcG9zaXRpb25zIHBhciB1biBwcm9kdWN0ZXVyIGFtw6lyaWNhaW4gcG91ciBvcmdhbmlzZXIgZGVzIGNvbmNlcnRzIGF2ZWMgY2VsdWktY2kuIO+7vzwvcD48L3NwYW4+
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ0NTAiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL3RpbmEtdGljdG9uZS1zYWlzb24tNC81MjQ2OTA1Ni0xLWZyZS1GUi9UaW5hLVRpY3RvbmUtc2Fpc29uLTRfcG9ydHJhaXRfdzg1OC5qcGciIHdpZHRoPSI4NTgiIGhlaWdodD0iNDY5IiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9IlRpbmEgVGljdG9uZSAoc2Fpc29uIDQpIiB0aXRsZT0iVGluYSBUaWN0b25lIChzYWlzb24gNCkiICAgLz4KICAgICAgICAgICAgCiAgICAKICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3NwYW4+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3Ryb25nPjxzcGFuPlRpbmEgVGljdG9uZSAoc2Fpc29uIDQpPC9zcGFuPjwvc3Ryb25nPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBjbGFzcz0iZGlhcG9fZGVzY3JpcHRpb25faXRlbSI+PHA+VGluYSBpbnTDqGdyZSBsZSBncm91cGUgV2lwcGluZyBXaWxsb3csIGNyb2lzw6kgZW50cmUgbGUgVHJpcC1ob3AgSmF6enkgZGUgVGhpZXJyeSBQYWxsYW56aSB0cmFuc2Zvcm3DqSBlbiBFbGVjdHJvIGNoYW5zb25zIGEgbGEgZnJhbsOnYWlzZSBwYXIgbGEgdm9peCBkZSBUaW5hIEdhcmRpbmllci4gRWxsZSBwb3Vyc3VpdCDDqWdhbGVtZW50IHNhIGNhcnJpw6hyZSBlbiBzb2xvIGV0IHNlIHByb2R1aXQgZGFucyBkZXMgc2FsbGVzIGRlIGNvbmNlcnQgZW4gRnJhbmNlLiA8L3A+PHA+77u/PC9wPjwvc3Bhbj4=
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ0NTIiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2xlbm5pZS1tYXJzaGFsbC1zYWlzb24tNC81MjQ2OTA3NC0xLWZyZS1GUi9MZW5uaWUtTWFyc2hhbGwtc2Fpc29uLTRfcG9ydHJhaXRfdzg1OC5qcGciIHdpZHRoPSI4NTgiIGhlaWdodD0iMTI2NyIgIHN0eWxlPSJib3JkZXI6IDBweCAgOyIgYWx0PSJMZW5uaWUgTWFyc2hhbGwgKHNhaXNvbiA0KSIgdGl0bGU9Ikxlbm5pZSBNYXJzaGFsbCAoc2Fpc29uIDQpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9zcGFuPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHN0cm9uZz48c3Bhbj5MZW5uaWUgTWFyc2hhbGwgKHNhaXNvbiA0KTwvc3Bhbj48L3N0cm9uZz4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHNwYW4gY2xhc3M9ImRpYXBvX2Rlc2NyaXB0aW9uX2l0ZW0iPjxwPkxlbm5pZSBzJ2VzdCBhaXPDqW1lbnQgZmFpdCBkZSBub21icmV1eCBjb250YWN0cyBzdWl0ZSDDoCBzb24gcGFzc2FnZSDDqWNsYWlyIMOgIGxhIFN0YXIgQWNhZGVteS4gTGVubmllIGEgcsOpYWxpc8OpIHVuZSBzw6lyaWUgZGUgY29uY2VydHMgUG9wIFJvY2sgZW4gMjAwNy4gRW4gMjAwOSwgZWxsZSBmYWl0IGxhIFVuZSBkZXMgam91cm5hdXggcG91ciBzb24gbWFyaWFnZSBhdmVjIGxlIGdhcmRpZW4gZGUgYnV0IGR1IFBTRyBNaWNrYcOrbCBMYW5kcmVhdS4gPC9wPjxwPu+7vzwvcD48L3NwYW4+
  • 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
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ0NTYiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL21hdGhpZXUtam9oYW5uLXNhaXNvbi00LzUyNDY5MTEwLTEtZnJlLUZSL01hdGhpZXUtSm9oYW5uLXNhaXNvbi00X3BvcnRyYWl0X3c4NTguanBnIiB3aWR0aD0iODU4IiBoZWlnaHQ9IjEyODAiICBzdHlsZT0iYm9yZGVyOiAwcHggIDsiIGFsdD0iTWF0aGlldSBKb2hhbm4gKHNhaXNvbiA0KSIgdGl0bGU9Ik1hdGhpZXUgSm9oYW5uIChzYWlzb24gNCkiICAgLz4KICAgICAgICAgICAgCiAgICAKICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8ZW0+JmNvcHk7IENIT0dOQVJEIEV0aWVubmUgLCBTVVJFQVUgSmVhbi1NPC9lbT48L3NwYW4+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3Ryb25nPjxzcGFuPk1hdGhpZXUgSm9oYW5uIChzYWlzb24gNCk8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD5FbiAyMDA1LCBpbCBzb3J0IHVuIGxpdnJlIGF1dG9iaW9ncmFwaGlxdWUgPGk+TGEgcGFzc2lvbiBwb3VyIHNldWwgYmFnYWdlPC9pPi4gRW4gMjAwOCBpbCBzb3J0IHNvbiBwcmVtaWVyIGFsYnVtIExlIGJvbmhldXIgw6dhIGZhaXQgbWFsIGV0IGVuY2hhw65uZSBsZXMgY29uY2VydHMgYXV4IDQgY29pbnMgZGUgbGEgRnJhbmNlLiBJbCBjb25uYcOudCB1biBqb2xpIHN1Y2PDqHMuIEVuIGTDqWNlbWJyZSAyMDExLCBpbCBzb3J0IHNvbiBzZWNvbmQgYWxidW0sIDxpPk1hY2hpbmUgw6AgcsOqdmVzPC9pPi7vu788L3A+PC9zcGFuPg==
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ0NTgiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL3NlYmFzdGllbi1kZWd1dC1zYWlzb24tNC81MjQ2OTEyOC0xLWZyZS1GUi9TZWJhc3RpZW4tRGVndXQtc2Fpc29uLTRfcG9ydHJhaXRfdzg1OC5qcGciIHdpZHRoPSI4NTgiIGhlaWdodD0iMjgyOCIgIHN0eWxlPSJib3JkZXI6IDBweCAgOyIgYWx0PSJTw6liYXN0aWVuIERlZ3V0IChzYWlzb24gNCkiIHRpdGxlPSJTw6liYXN0aWVuIERlZ3V0IChzYWlzb24gNCkiICAgLz4KICAgICAgICAgICAgCiAgICAKICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8ZW0+JmNvcHk7IEFVQkVSVCBDaHJpc3RvcGhlPC9lbT48L3NwYW4+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3Ryb25nPjxzcGFuPlPDqWJhc3RpZW4gRGVndXQgKHNhaXNvbiA0KTwvc3Bhbj48L3N0cm9uZz4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHNwYW4gY2xhc3M9ImRpYXBvX2Rlc2NyaXB0aW9uX2l0ZW0iPjxwPklsIGEgcGFydGljaXDDqSDDoCBkZXV4IGNsaXBzIHRyw6hzIHNlbnN1ZWxzIGF1eCBjw7R0w6lzIGQnRWxvZGllIEZyw6lnw6kuIO+7vzwvcD48L3NwYW4+
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ0NjAiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2VtaWxpZS1kdWNyb3Qtc2Fpc29uLTQvNTI0NjkxNDYtMS1mcmUtRlIvRW1pbGllLUR1Y3JvdC1zYWlzb24tNF9wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1NyIgaGVpZ2h0PSI1NjkiICBzdHlsZT0iYm9yZGVyOiAwcHggIDsiIGFsdD0iw4ltaWxpZSBEdWNyb3QgKHNhaXNvbiA0KSIgdGl0bGU9IsOJbWlsaWUgRHVjcm90IChzYWlzb24gNCkiICAgLz4KICAgICAgICAgICAgCiAgICAKICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8ZW0+JmNvcHk7IENIT0dOQVJEIEV0aWVubmUgLyBTVVJFQVUgSmVhbi1NPC9lbT48L3NwYW4+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3Ryb25nPjxzcGFuPsOJbWlsaWUgRHVjcm90IChzYWlzb24gNCk8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD5FbiBhdnJpbCAyMDA1LCBFbWlsaWUsIGVzdCBFbXkgTGVlIHF1aSBhIHBlcmR1IDE3IGtpbG9zLCBzJ2VzdCBjb3Vww6llIGxlcyBjaGV2ZXV4LCBhIGNoYW5nw6kgZGUgbm9tIGV0IGEgbGFyZ3XDqSBzb24gcGV0aXQgY29wYWluLiBNYWlzLCBlbiAyMDA2LCBsZXMgMTAgZmluYWxpc3RlcyBkZSBMYSBOb3V2ZWxsZSBzdGFyIDQgc3VyIE02IHByw6lzZW50YWllbnQgbGUgbm91dmVhdSBzaW5nbGUgZGUgbCfDqW1pc3Npb24sIDxpPkonaXJhaSBjaGFudGVyPC9pPiwgdW5lIGNoYW5zb24gaW7DqWRpdGUgc2lnbsOpZSBNYXJpZS1Kb3PDqSBaYXJiIGV0IExhdXJhIE1hcmNpYW5vLiDDiW1pbGllIER1Y3JvdCBkZXZhaXQgbGFuY2VyIHNvbiBwcmVtaWVyIGFsYnVtLi4uIMOpZ2FsZW1lbnQgaW50aXR1bMOpIEo8aT4naXJhaSBjaGFudGVyICE8L2k+IFVuIHZvbCBkZSBjaGFuc29uIHF1aSBsdWkgYSBmYWl0IGJlYXVjb3VwIGRlIHRvcnQuIEF1eCBkZXJuacOocmVzIG5vdXZlbGxlcywgZWxsZSB2aXQgw6AgTHlvbiBldCBhIHN1aXZpIHVuZSDDqWNvbGUgZW4gbWFxdWlsbGFnZSBwcm8u77u/PC9wPjwvc3Bhbj4=
  • PHNwYW4gaWQ9InBob3RvXzMyMzQ0NjIiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy0xMC1hbnMtZGUtc3Rhci1hY2FkZW15LXF1ZS1zb250LWRldmVudXMtbGVzLWNhbmRpZGF0cy1kZXMtc2Fpc29ucy0xLWEtNC0zMDM0NTMyL2VucmlxdWUtdG95b3Mtc2Fpc29uLTQvNTI0NjkxNjQtMS1mcmUtRlIvRW5yaXF1ZS1Ub3lvcy1zYWlzb24tNF9wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSI1NjciICBzdHlsZT0iYm9yZGVyOiAwcHggIDsiIGFsdD0iRW5yaXF1ZSBUb3lvcyAoc2Fpc29uIDQpIiB0aXRsZT0iRW5yaXF1ZSBUb3lvcyAoc2Fpc29uIDQpIiAgIC8+CiAgICAgICAgICAgIAogICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGVtPiZjb3B5OyBTVVJFQVUgSmVhbi1NYXJjIC8gQ0hPR05BUkQgRXRpZTwvZW0+PC9zcGFuPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHN0cm9uZz48c3Bhbj5FbnJpcXVlIFRveW9zIChzYWlzb24gNCk8L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD5JbCBkZXZpZW50IE4ncmlrw6kgTW9udG95YSDDqWNyaXQgZXQgY29tcG9zZSBzZXMgdGl0cmVzIGRhbnMgbCdlc3BvaXIgZCdlbnJlZ2lzdHJlciBzb24gYWxidW0uIElsIHNlIHByb2R1aXQgZG9uYyBzdXIgbGVzIHNjw6huZXMgZGUgRnJhbmNlIHNldWwgb3UgYXZlYyBzZXMgYW5jaWVucyBjYW1hcmFkZXMgZGUgMjAwNiDDoCAyMDA3LiBFbiAyMDExLCBOJ3Jpa8OpIE1vbnRveWEgZmFpdCBzb24gY29tZS1iYWNrIGVuIGludGVycHLDqXRhbnQgdW4gZmVhdHVyaW5nIGF2ZWMgTmFzdHktUm9ndWUuIO+7vzwvcD48L3NwYW4+
  • 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
  • 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
  • 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
  • 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
Toutes les photos (67)Toutes les photos (67)
En savoir plus
Star Academy
Star Academy
Star Academy saison 1
Star Academy saison 1
Star Academy saison 2
Star Academy saison 2
Star Academy saison 3
Star Academy saison 3
Star Academy saison 4
Star Academy saison 4
The Voice : Madonna, Lady Gaga et Paul Mc Cartney, invités presentis pour les live
The Voice : Madonna, Lady Gaga et Paul Mc Cartney, invités...
The Voice : Les diverses réactions des people sur Twitter
The Voice : Les diverses réactions des people sur Twitter
SONDAGE - The Voice : Elodie Frégé est le candidat de télé-réalité qui vous a le plus marqué!
SONDAGE - The Voice : Elodie Frégé est le candidat de...
Objectif party : la nouvelle émission réalité de NRJ12
Objectif party : la nouvelle émission réalité de NRJ12
Les Anges de la télé-réalité 4 : les noms des douze candidats !
Les Anges de la télé-réalité 4 : les noms des douze...
Secret Story 6 : l'émission devrait commencer en mai sur TF1 et Star Academy en octobre sur NRJ12
Secret Story 6 : l'émission devrait commencer en mai sur TF1...
Les derniers diaporamas photos télé
COMMENTAIRES
10
Connectez-vous en cliquant ici pour laisser un commentaire en utilisant votre pseudo. Si vous ne vous loguez pas, votre commentaire n'apparaîtra qu'en ANONYME.
Afficher les messages :
gregory <3!!!!!!! c'est le meilleur :D!!!
  • 0
  • 0
poussyianna | le 27/12/2011 à 21h45 | Signaler un abus
répondre
Votre réponse...
GREGORY!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! c'est le meilleur des meilleurs :D!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  • 0
  • 0
Anonyme | le 27/12/2011 à 21h42 | Signaler un abus
répondre
Votre réponse...
c'est si bon de revoir Michal mais pas suffisant, je viens de voir la redif, j'ai l'impression que l'on zappe la saison 3 alors que c'était une des meilleures, pas de Bamba, pas d'Elodie, pas d'actu pour elle et Michal, pourquoi ??? alors qu'ils font toujours partie du paysage musical
  • 0
  • 0
Anonyme | le 17/12/2011 à 20h54 | Signaler un abus
répondre
Votre réponse...
un seul candidat m'a touché : Michal, auteur, compositeur, interprète et maintenant producteur de son projet Self Concept avec la sorite de l'album grandisoe "What's your name ?" à découvrir absolument les médias font une grave erreur de le bouder à cause de l'étiquette Starac, c'est un artiste fabuleux ! Sur scène, il nous fait passer du grand frisson au délire le plus fou...à voir à la Boule Noire à Paris le 4 février 2012
  • 0
  • 0
Anonyme | le 16/12/2011 à 13h29 | Signaler un abus
répondre
Votre réponse...
Sofia <3 Que de chemin parcouru ! Heureusement la talent fini toujours par payer :)
  • 0
  • 0
Anonyme | le 10/12/2011 à 21h19 | Signaler un abus
répondre
Votre réponse...
Appart Jennifer, Olivia Ruiz, Elodie Freger, Emma Daumas, Sofia Essaidi en filles ! et Jean Pascal, Mario, George Alain et SURTOUT Gregory Lemarchal ! les autres pas je vois vraiment pas qui c'est !! c''est horrible de pas s'en souvenir !!! 8 sur au moins 100 ! LOOOL
  • 0
  • 0
Anonyme | le 10/12/2011 à 17h13 | Signaler un abus
répondre
Votre réponse...
Jen ♥
  • 0
  • 0
Anonyme | le 10/12/2011 à 16h35 | Signaler un abus
répondre
Votre réponse...
on les a tous oubliés et ils n'ont rien branlé derrière car ils étaient des ratés sans talent !
  • 0
  • 0
Anonyme | le 10/12/2011 à 13h58 | Signaler un abus
répondre
Votre réponse...
Que de souvenir <3<3
  • 0
  • 0
Anonyme | le 10/12/2011 à 11h13 | Signaler un abus
répondre
Votre réponse...
François Roure est un chanteur raté, je tiens à ajouter qu'il a aussi mal pris de se faire recaler à Incroyable Talent auquel il a aussi présenté sa chorale... Enfin bon, j'dis ça...
  • 0
  • 0
Anonyme | le 09/12/2011 à 21h14 | Signaler un abus
répondre
Votre réponse...
HAUT
Les Tweets de Thierry Moreau
Programme TV avecTélé7
  • 20h50 Les experts 2
  • 20h35 Clash 77
  • 20h35 Des racines et des ailes 77
  • 20h55 La conquête 77
  • 20h35 La maison France 5
  • 20h50 Pékin express, le passager mystère 77
  • 20h35 Gomorra 777
  • 22h45 Chirac rebat la campagne 0
  • 20h40 Inception 7777
  • 20h40 Après la gauche 777
> Tout le programme TV
La vidéo du jour
  • Zapping hebdo N°14 : Michaël Youn haut perché
> Toutes les vidéos tv
La sélection Replay avecTV-replay
  • Code Lyoko Code Lyoko Retour dans le laboratoire d'Amazonie pour Kadic, Yumi, Ulrich, Odd et Jérém ...
  • Les hommes du Fer Les hommes du Fer En 1945, dans une Europe en ruines, la sidérurgie devient le fer de lance de ...
  • L'Allemagne sauvage L'Allemagne sauvage Situé non loin de la frontière française, le massif est remarquable pour ses ...
    > Tout TV-replay
    Audiences TV
    Audience télé du 22/05 (source : Médiamétrie)
    • 25.6% Dr House 7 122 000 téléspectateurs
    • 15.6% Le dindon 3 902 000 téléspectateurs
    • 11.2% Cauchemar en cuisine 3 029 000 téléspectateurs
    > Toutes les audiences TV
    Plus d'émissions
    A lire également