PHOTOS - Cannes 2010 : Tatiana et Xavier, Leslie, Angie, Greg Basso, FX ... ils ont fait le show, mais avaient-ils vraiment leur place au Festival ?

23/05/2010 - 18h56
  • 71
  • Les deux tendres amoureux Tatiana et Xavier Leslie la provocatrice ! Angie le retour ! Greg Basso a présenté sa chérie ! Célyne Durand par ci ... ... Célyne Durand par là ! FX complètement éteint ! Le duo Surya Bonaly et Christophe Guillarmé ! Karine Dupray de la Ferme Célébrités était là aussi ! Tatiana pour une pose seule Angie transformée en Tina Turner ! Les trois compères de la Ferme Célébrités ! Leslie, plus vulgaire que jamais !
  • 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
  • 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
  • PHNwYW4gaWQ9InBob3RvXzI1MTQ0ODgiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy9wdWJsaWMvcGhvdG9zLXBlb3BsZS9waG90b3MtY2FubmVzLTIwMTAtdGF0aWFuYS1ldC14YXZpZXItbGVzbGllLWFuZ2llLWdyZWctYmFzc28tZngtaWxzLW9udC1mYWl0LWxlLXNob3ctbWFpcy1hdmFpZW50LWlscy12cmFpbWVudC1sZXVyLXBsYWNlLWF1LWZlc3RpdmFsL2FuZ2llLWxlLXJldG91ci0vMzQyMTEzODctMS1mcmUtRlIvQW5naWUtbGUtcmV0b3VyLV9wb3J0cmFpdF93ODU4LmpwZyIgd2lkdGg9Ijg1OCIgaGVpZ2h0PSIxMDYzIiAgc3R5bGU9ImJvcmRlcjogMHB4ICA7IiBhbHQ9IkFuZ2llIGxlIHJldG91ciAhICIgdGl0bGU9IkFuZ2llIGxlIHJldG91ciAhICIgICAvPgogICAgICAgICAgICAKICAgIAogICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxlbT4mY29weTsgQWJhY2E8L2VtPjwvc3Bhbj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzdHJvbmc+PHNwYW4+QW5naWUgbGUgcmV0b3VyICEgPC9zcGFuPjwvc3Ryb25nPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBjbGFzcz0iZGlhcG9fZGVzY3JpcHRpb25faXRlbSI+PHA+PGI+Q2V0dGUgYW5uw6llLCBvbiBhIHRyw6hzIGNlcnRhaW5lbWVudCBiYXR0dSB0b3VzIGxlcyByZWNvcmRzIGRlICZxdW90O3N0YXJzJnF1b3Q7IGRlIGxhIHTDqWzDqXLDqWFsaXTDqSBwcsOpc2VudGVzIMOgIENhbm5lcyAhPC9iPiBBbG9ycyBxdWUgY2UgZ3JhbmQgw6l2w6huZW1lbnQgZ2xhbW91ciBjw6lsw6hicmUgbGUgbWVpbGxldXIgZHUgY2luw6ltYSwgbGVzIGFjdGV1cnMgbmUgc29udCBwYXMgbGVzIHNldWxzIMOgIHBvdXZvaXIgZ3JhdmlyIGxlcyBwcmVzdGlnaWV1c2VzIG1hcmNoZXMgZHUgcGFsYWlzIGRlcyBmZXN0aXZhbHMuIER1IGNvdXAsIG9uIGF1cmEgdnUgdW4gcGV1IGRlIHRvdXQgcG91ciBjZSA2MyDDqG1lIGZlc3RpdmFsIGV0IHN1cnRvdXQgZGVzIHBlcnNvbm5hbGl0w6lzIGlzc3VlcyBkZSA8aT5TZWNyZXQgU3Rvcnk8L2k+LCBkZSA8aT5sYSBGZXJtZSBDw6lsw6licml0w6lzPC9pPiwgb3UgZW5jb3JlIGRlIDxpPkxvZnQgU3Rvcnk8L2k+IChldCBvdWksIMOnYSByZW1vbnRlIGxvaW4gdG91dCDDp2EgISkuPC9wPjxwPkV0IHNpIDxiPmNlcnRhaW5lcyBkZSBjZXMgJnF1b3Q7c3RhcnMmcXVvdDsgb250IGp1c3RlIHZvdWx1IGZhaXJlIHVuZSBicsOodmUgYXBwYXJpdGlvbjwvYj4sIDxhIGhyZWY9Imh0dHA6Ly9wZW9wbGUucHJlbWllcmUuZnIvUGhvdG9zLXBlb3BsZS9QSE9UT1MtQ2FubmVzLTIwMTAtR3JlZy1CYXNzby1hbW91cmV1eC1ldC1jbGFzc2UtcG91ci1zYS1tb250ZWUtZGVzLW1hcmNoZXMtaWwtbm91cy1wcmVzZW50ZS1lbmZpbi1zYS1jaGVyaWUtLTIzMjcxOTUiIHRhcmdldD0iX3NlbGYiPjxiPmNvbW1lIEdyZWcgQmFzc288L2I+IHBhciBleGVtcGxlIGF2ZWMgc2EgY2jDqXJpZTwvYT4sIGQnYXV0cmVzIG4nb250IHBhcyBhcnLDqnTDqSBkZSBzZSBtb250cmVyLiBDJ2VzdCBpbmNvbnRlc3RhYmxlbWVudCA8Yj48YSBocmVmPSJodHRwOi8vcGVvcGxlLnByZW1pZXJlLmZyL1Bob3Rvcy1wZW9wbGUvUEhPVE9TLUNhbm5lcy0yMDEwLUNlbHluZS1EdXJhbmQtbC1hbmNpZW5uZS1jYW5kaWRhdGUtZGUtTGEtRmVybWUtQ2VsZWJyaXRlcy1zdXItdG91cy1sZXMtZnJvbnRzLS1OLWVuLWZhaXQtZWxsZS1wYXMtdW4tcGV1LXRyb3AtMjMyMjQyMiIgdGFyZ2V0PSJfc2VsZiI+Q8OpbHluZSBEdXJhbmQgcXVpIHJlbXBvcnRlIGxhIHBhbG1lIGQnb3IgZHUgbm9tYnJlIGRlIHRhcGlzIHJvdWdlcyBldCBhcHBhcml0aW9ucyBlbiBzb2lyw6llczwvYT48L2I+LCA8YSBocmVmPSJodHRwOi8vd3d3LnByZW1pZXJlLmZyL0xlcy1WRE0tUGVvcGxlL0xhLVZETS1wZW9wbGUtRGVnYWdlZS1kZS1mb3JjZS0yMzI2ODI0IiB0YXJnZXQ9Il9zZWxmIj5hdSBwb2ludCBxdWUgbGEgYmxvbmRpbmV0dGUgcydlc3QgbcOqbWUgZmFpdCBkw6lnYWdlciBkZSBmb3JjZTwvYT4gISBQb3VyIGNlIHF1aSBlc3QgZGUgPGI+PGEgaHJlZj0iaHR0cDovL3Blb3BsZS5wcmVtaWVyZS5mci9QaG90b3MtcGVvcGxlL1BIT1RPUy1DYW5uZXMtMjAxMC1MZXNsaWUtZGUtTG9mdC1TdG9yeS0yLXRyZXMtdHJlcy10cmVzLWRldmV0dWUtcG91ci1tb250ZXItbGVzLW1hcmNoZXMtLVF1ZWxsZS1leGhpYml0aW9ubmlzdGUtLTIzMjE2MTUiIHRhcmdldD0iX3NlbGYiPmxhIHBhbG1lIGRlIGxhIHZ1bGdhcml0w6ksIG9uIGxhIGTDqWNlcm5lIHNhbnMgYXVjdW5lIGjDqXNpdGF0aW9uIMOgIExlc2xpZSBkZSBMb2Z0IFN0b3J5IDI8L2E+PC9iPiwgcXVpIGVuIG1vbnRyYW50IHNlcyBmZXNzZXMgZGFucyBzYSByb2JlIHRyYW5zcGFyZW50ZSBub3VzIGEgcHJvdXbDqSBxdSdlbGxlIGluY2FybmFpdCB0b3V0IHNhdWYgbGUgZ2xhbW91ci48L3A+PHA+RXQgcHVpcyBpbCB5IGEgVGF0aWFuYSBldCBYYXZpZXIsIHVuIGNvdXBsZSBxdWkgYWltZSBzZSBtb250cmVyIG1haXMgcXVpIGF1IGZpbmFsIGVzdCBqdXN0ZSBsw6AgcG91ciBqb3VlciBsZXMgYW1vdXJldXggZXQgcXVpIDxhIGhyZWY9Imh0dHA6Ly9wZW9wbGUucHJlbWllcmUuZnIvTmV3cy12aWRlb3MvRVhDTFUtVklERU8tQ2FubmVzLTIwMTAtVGF0aWFuYS1ldC1YYXZpZXItZGUtU2VjcmV0LVN0b3J5LU9uLW5lLWNoZXJjaGUtcGFzLWEtZXRyZS1hY3RldXJzLWEtSG9sbHl3b29kLTIzMjYzNTciIHRhcmdldD0iX3NlbGYiPm5lIHByw6l0ZW5kIHBhcyBkdSB0b3V0IMOgIGZhaXJlIGNhcnJpw6hyZSBkYW5zIGxlIGNpbsOpbWEgY29tbWUgbGVzIGRldXggdG91cnRlcmVhdXggbm91cyBsJ29udCBjb25macOpPC9hPi48L3A+PHA+PGI+TWFpcyBhdSBmaW5hbCwgdW5lIHNldWxlIHF1ZXN0aW9uIHNlIHBvc2UsIExlc2xpZSwgQW5naWUsIFRhdGlhbmEsIEdyZWcgZXQgbGVzIGF1dHJlcyBhdmFpZW50LWlscyB2cmFpbWVudCBsZXVyIHBsYWNlIGF1IEZlc3RpdmFsIGRlIENhbm5lcyA/IDwvYj48L3A+PC9zcGFuPg==
  • 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
  • PHNwYW4gaWQ9InBob3RvXzI1MTQ0OTAiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy9wdWJsaWMvcGhvdG9zLXBlb3BsZS9waG90b3MtY2FubmVzLTIwMTAtdGF0aWFuYS1ldC14YXZpZXItbGVzbGllLWFuZ2llLWdyZWctYmFzc28tZngtaWxzLW9udC1mYWl0LWxlLXNob3ctbWFpcy1hdmFpZW50LWlscy12cmFpbWVudC1sZXVyLXBsYWNlLWF1LWZlc3RpdmFsL2NlbHluZS1kdXJhbmQtcGFyLWNpLzM0MjExNDA1LTEtZnJlLUZSL0NlbHluZS1EdXJhbmQtcGFyLWNpX3BvcnRyYWl0X3c4NTguanBnIiB3aWR0aD0iODU4IiBoZWlnaHQ9IjE2MzYiICBzdHlsZT0iYm9yZGVyOiAwcHggIDsiIGFsdD0iQ8OpbHluZSBEdXJhbmQgcGFyIGNpIC4uLiIgdGl0bGU9IkPDqWx5bmUgRHVyYW5kIHBhciBjaSAuLi4iICAgLz4KICAgICAgICAgICAgCiAgICAKICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8ZW0+JmNvcHk7IEFiYWNhPC9lbT48L3NwYW4+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3Ryb25nPjxzcGFuPkPDqWx5bmUgRHVyYW5kIHBhciBjaSAuLi48L3NwYW4+PC9zdHJvbmc+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzcGFuIGNsYXNzPSJkaWFwb19kZXNjcmlwdGlvbl9pdGVtIj48cD48Yj5DZXR0ZSBhbm7DqWUsIG9uIGEgdHLDqHMgY2VydGFpbmVtZW50IGJhdHR1IHRvdXMgbGVzIHJlY29yZHMgZGUgJnF1b3Q7c3RhcnMmcXVvdDsgZGUgbGEgdMOpbMOpcsOpYWxpdMOpIHByw6lzZW50ZXMgw6AgQ2FubmVzICE8L2I+IEFsb3JzIHF1ZSBjZSBncmFuZCDDqXbDqG5lbWVudCBnbGFtb3VyIGPDqWzDqGJyZSBsZSBtZWlsbGV1ciBkdSBjaW7DqW1hLCBsZXMgYWN0ZXVycyBuZSBzb250IHBhcyBsZXMgc2V1bHMgw6AgcG91dm9pciBncmF2aXIgbGVzIHByZXN0aWdpZXVzZXMgbWFyY2hlcyBkdSBwYWxhaXMgZGVzIGZlc3RpdmFscy4gRHUgY291cCwgb24gYXVyYSB2dSB1biBwZXUgZGUgdG91dCBwb3VyIGNlIDYzIMOobWUgZmVzdGl2YWwgZXQgc3VydG91dCBkZXMgcGVyc29ubmFsaXTDqXMgaXNzdWVzIGRlIDxpPlNlY3JldCBTdG9yeTwvaT4sIGRlIDxpPmxhIEZlcm1lIEPDqWzDqWJyaXTDqXM8L2k+LCBvdSBlbmNvcmUgZGUgPGk+TG9mdCBTdG9yeTwvaT4gKGV0IG91aSwgw6dhIHJlbW9udGUgbG9pbiB0b3V0IMOnYSAhKS48L3A+PHA+RXQgc2kgPGI+Y2VydGFpbmVzIGRlIGNlcyAmcXVvdDtzdGFycyZxdW90OyBvbnQganVzdGUgdm91bHUgZmFpcmUgdW5lIGJyw6h2ZSBhcHBhcml0aW9uPC9iPiwgPGEgaHJlZj0iaHR0cDovL3Blb3BsZS5wcmVtaWVyZS5mci9QaG90b3MtcGVvcGxlL1BIT1RPUy1DYW5uZXMtMjAxMC1HcmVnLUJhc3NvLWFtb3VyZXV4LWV0LWNsYXNzZS1wb3VyLXNhLW1vbnRlZS1kZXMtbWFyY2hlcy1pbC1ub3VzLXByZXNlbnRlLWVuZmluLXNhLWNoZXJpZS0tMjMyNzE5NSIgdGFyZ2V0PSJfc2VsZiI+PGI+Y29tbWUgR3JlZyBCYXNzbzwvYj4gcGFyIGV4ZW1wbGUgYXZlYyBzYSBjaMOpcmllPC9hPiwgZCdhdXRyZXMgbidvbnQgcGFzIGFycsOqdMOpIGRlIHNlIG1vbnRyZXIuIEMnZXN0IGluY29udGVzdGFibGVtZW50IDxiPjxhIGhyZWY9Imh0dHA6Ly9wZW9wbGUucHJlbWllcmUuZnIvUGhvdG9zLXBlb3BsZS9QSE9UT1MtQ2FubmVzLTIwMTAtQ2VseW5lLUR1cmFuZC1sLWFuY2llbm5lLWNhbmRpZGF0ZS1kZS1MYS1GZXJtZS1DZWxlYnJpdGVzLXN1ci10b3VzLWxlcy1mcm9udHMtLU4tZW4tZmFpdC1lbGxlLXBhcy11bi1wZXUtdHJvcC0yMzIyNDIyIiB0YXJnZXQ9Il9zZWxmIj5Dw6lseW5lIER1cmFuZCBxdWkgcmVtcG9ydGUgbGEgcGFsbWUgZCdvciBkdSBub21icmUgZGUgdGFwaXMgcm91Z2VzIGV0IGFwcGFyaXRpb25zIGVuIHNvaXLDqWVzPC9hPjwvYj4sIDxhIGhyZWY9Imh0dHA6Ly93d3cucHJlbWllcmUuZnIvTGVzLVZETS1QZW9wbGUvTGEtVkRNLXBlb3BsZS1EZWdhZ2VlLWRlLWZvcmNlLTIzMjY4MjQiIHRhcmdldD0iX3NlbGYiPmF1IHBvaW50IHF1ZSBsYSBibG9uZGluZXR0ZSBzJ2VzdCBtw6ptZSBmYWl0IGTDqWdhZ2VyIGRlIGZvcmNlPC9hPiAhIFBvdXIgY2UgcXVpIGVzdCBkZSA8Yj48YSBocmVmPSJodHRwOi8vcGVvcGxlLnByZW1pZXJlLmZyL1Bob3Rvcy1wZW9wbGUvUEhPVE9TLUNhbm5lcy0yMDEwLUxlc2xpZS1kZS1Mb2Z0LVN0b3J5LTItdHJlcy10cmVzLXRyZXMtZGV2ZXR1ZS1wb3VyLW1vbnRlci1sZXMtbWFyY2hlcy0tUXVlbGxlLWV4aGliaXRpb25uaXN0ZS0tMjMyMTYxNSIgdGFyZ2V0PSJfc2VsZiI+bGEgcGFsbWUgZGUgbGEgdnVsZ2FyaXTDqSwgb24gbGEgZMOpY2VybmUgc2FucyBhdWN1bmUgaMOpc2l0YXRpb24gw6AgTGVzbGllIGRlIExvZnQgU3RvcnkgMjwvYT48L2I+LCBxdWkgZW4gbW9udHJhbnQgc2VzIGZlc3NlcyBkYW5zIHNhIHJvYmUgdHJhbnNwYXJlbnRlIG5vdXMgYSBwcm91dsOpIHF1J2VsbGUgaW5jYXJuYWl0IHRvdXQgc2F1ZiBsZSBnbGFtb3VyLjwvcD48cD5FdCBwdWlzIGlsIHkgYSBUYXRpYW5hIGV0IFhhdmllciwgdW4gY291cGxlIHF1aSBhaW1lIHNlIG1vbnRyZXIgbWFpcyBxdWkgYXUgZmluYWwgZXN0IGp1c3RlIGzDoCBwb3VyIGpvdWVyIGxlcyBhbW91cmV1eCBldCBxdWkgPGEgaHJlZj0iaHR0cDovL3Blb3BsZS5wcmVtaWVyZS5mci9OZXdzLXZpZGVvcy9FWENMVS1WSURFTy1DYW5uZXMtMjAxMC1UYXRpYW5hLWV0LVhhdmllci1kZS1TZWNyZXQtU3RvcnktT24tbmUtY2hlcmNoZS1wYXMtYS1ldHJlLWFjdGV1cnMtYS1Ib2xseXdvb2QtMjMyNjM1NyIgdGFyZ2V0PSJfc2VsZiI+bmUgcHLDqXRlbmQgcGFzIGR1IHRvdXQgw6AgZmFpcmUgY2FycmnDqHJlIGRhbnMgbGUgY2luw6ltYSBjb21tZSBsZXMgZGV1eCB0b3VydGVyZWF1eCBub3VzIGwnb250IGNvbmZpw6k8L2E+LjwvcD48cD48Yj5NYWlzIGF1IGZpbmFsLCB1bmUgc2V1bGUgcXVlc3Rpb24gc2UgcG9zZSwgTGVzbGllLCBBbmdpZSwgVGF0aWFuYSwgR3JlZyBldCBsZXMgYXV0cmVzIGF2YWllbnQtaWxzIHZyYWltZW50IGxldXIgcGxhY2UgYXUgRmVzdGl2YWwgZGUgQ2FubmVzID8gPC9iPjwvcD48L3NwYW4+
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
COMMENTAIRES
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.
tatiana est magnifique et xavier un vrai bo gosses
  • 0
  • 0
Anonyme | le 25/05/2010 à 19h43 | Signaler un abus
Votre réponse...
NOOOOOONNNNNN (cf titre : ils n'avaient pas leur place au festival) !! Quelle question !
  • 0
  • 0
Anonyme | le 25/05/2010 à 16h38 | Signaler un abus
Votre réponse...
Je trouve que ces personne n'ont rien a faire au festival de cannes ! c'est le festival du film, pas de la téléréalité & de la vulgarité !
  • 0
  • 0
Anonyme | le 25/05/2010 à 14h40 | Signaler un abus
Votre réponse...
18h41 ouais attend moi aussi je vien avec toi mdrrr
  • 0
  • 0
Anonyme | le 25/05/2010 à 11h17 | Signaler un abus
Votre réponse...
trop belle Tatiana!!! MDR BELLE DE LOIN et LOIN D ETRE BELLE!!!!! qu'elle apprenne à parler déja.Ils révent !!!!
  • 0
  • 0
Anonyme | le 24/05/2010 à 23h20 | Signaler un abus
Votre réponse...
MAIS QUI LES INVITENT DEJA JE PIGE PAS ET IL VIENNENT PKOI FAIRE ????? a part nous remontrer leurs gueules
  • 0
  • 0
Anonyme | le 24/05/2010 à 20h19 | Signaler un abus
Votre réponse...
N'importe quoi Cannes cette année avec eux, soit disant aucun candidat de la télé-réalité, pfffff!! J'espère qu'ils feront le tri l'année prochaine sinon moi j'enfile ma plus belle tenue et j'y vais ^^
  • 0
  • 0
Anonyme | le 24/05/2010 à 18h41 | Signaler un abus
Votre réponse...
ils n'ont rien à y faire!!!!
  • 0
  • 0
Anonyme | le 24/05/2010 à 18h22 | Signaler un abus
Votre réponse...
Trop d'accord avec anonyme 14h56!!! Ces gens n'ont aucun talent, n'ont rien fait à part montrer leur cul ou leurs seins - et le font encore - pour mériter d'apparaitre dans les magasine... Mais ça à l'air de plaire...
  • 0
  • 0
Anonyme | le 24/05/2010 à 15h15 | Signaler un abus
Votre réponse...
En même temps si vous la presse people arretiez de nous pomper l'air et de les mettre a la une de vos magazines ils arreteraient un peu de se prendre pour des stars et tout le monde seraient enfin tranquille, ce serait bien d'avoir des vrais stars qui ont un vrai metier au lieu de nous mettre ses ratés qui s'inventent une vie de stars toutes les semaines.
  • 0
  • 0
Anonyme | le 24/05/2010 à 14h56 | Signaler un abus
Votre réponse...
La vidéo du jour
  • Amour