0byt3m1n1
Path:
/
home
/
mgatv524
/
public_html
/
sommatv
/
web
/
media
/
cache
/
0fea6a13c52b4d47
/
25368f24b045ca84
/
b8ac4316b44f99ee
/
f0cf6447439815bc
/
9d2b1ad5bbc16c44
/
d49116dc213c53f2
/
8a084cf70d891601
/
51bfe9722cb4c124
/
06ceabc6a54510f0
/
[
Home
]
File: 3b6386a1946f336d.php
<?php /* Cachekey: cache/xibo/widget/ticker/ab4d966a31567ee26adb32b749b86665/ */ /* Type: array */ /* Expiration: 2018-05-08T12:13:39-05:00 */ $loaded = true; $expiration = 1525799619; $data = array(); /* Child Type: array */ $data['return'] = unserialize(base64_decode('a:2:{s:8:"encoding";s:5:"UTF-8";s:3:"xml";s:112463:"<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	xmlns:georss="http://www.georss.org/georss" xmlns:geo="http://www.w3.org/2003/01/geo/wgs84_pos#" xmlns:media="http://search.yahoo.com/mrss/"
	>

<channel>
	<title>VEJA.com</title>
	<atom:link href="https://veja.abril.com.br/feed/" rel="self" type="application/rss+xml" />
	<link>https://veja.abril.com.br</link>
	<description>Notícias sobre política, economia, celebridades, mundo e esportes. Coberturas e reportagens especiais em TVEJA.</description>
	<lastBuildDate>Tue, 08 May 2018 16:22:29 +0000</lastBuildDate>
	<language>pt-BR</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	
<cloud domain='veja.abril.com.br' port='80' path='/?rsscloud=notify' registerProcedure='' protocol='http-post' />
<image>
		<url>https://secure.gravatar.com/blavatar/e28656f5f48542eafbe3f88df312a7ed?s=96&#038;d=https%3A%2F%2Fs0.wp.com%2Fi%2Fbuttonw-com.png</url>
		<title>VEJA.com</title>
		<link>https://veja.abril.com.br</link>
	</image>
	<atom:link rel="search" type="application/opensearchdescription+xml" href="https://veja.abril.com.br/osd.xml" title="VEJA.com" />
	<atom:link rel='hub' href='https://veja.abril.com.br/?pushpress=hub'/>
	<item>
		<title>Xuxa faz homenagem à mãe, Alda Meneghel, nas redes: &#8216;Meu passarinho voou&#8217;</title>
		<link>https://veja.abril.com.br/entretenimento/xuxa-faz-homenagem-a-mae-nas-redes-meu-passarinho-voou/</link>
		<comments>https://veja.abril.com.br/entretenimento/xuxa-faz-homenagem-a-mae-nas-redes-meu-passarinho-voou/#respond</comments>
		<pubDate>Tue, 08 May 2018 15:57:57 +0000</pubDate>
		<dc:creator><![CDATA[Maria Carolina Maia]]></dc:creator>
				<category><![CDATA[Entretenimento]]></category>
		<category><![CDATA[Obituário]]></category>
		<category><![CDATA[Xuxa]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525688</guid>
		<description><![CDATA[Apresentadora ainda agradeceu às orações dos fãs, e disse que a mãe agora vai 'pintar um lindo pôr do sol para nós']]></description>
				<content:encoded><![CDATA[<p>A apresentadora <strong>Xuxa</strong> fez uma rápida passagem pelas redes sociais para um post delicado em homenagem à mãe, <strong>Dona Alda</strong>, morta aos 81 anos depois de mais de dez anos de luta contra o mal de Parkinson.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/entretenimento">Entretenimento</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/entretenimento/morre-alda-meneghel-mae-de-xuxa-aos-81-anos/">Morre Alda Meneghel, mãe de Xuxa, aos 81 anos</a></span><span class="widget-news-item-date">8 maio 2018 - 11h05</span></div></li></ul></div>
<p>&#8220;<span>Meu passarinho voou&#8230; e vai pintar um lindo pôr do sol para nós&#8230; obrigada a todos pelas orações&#8221;, escreveu Xuxa, ao lado de uma foto em que Alda Meneghel aparece em uma cadeira de rodas, pintando um quadro.</span></p>
<p><a href="https://www.instagram.com/p/BihbHIXgGpA/?taken-by=xuxamenegheloficial" title="Ver no Instagram" target="_blank"><img src="http://instagr.am/p/BihbHIXgGpA/media/?size=l" alt="Instagram Photo" /></a></p>
<p>Xuxa vinha compartilhando mensagens no Instagram com os fãs, pedindo energias positivas para a mãe. Alda lutava contra o Parkinson em estágio avançado e, em 2016 sofreu dois Acidentes Vasculares Cerebrais (AVC).</p>
<p>Os fãs da apresentadora estão prestando solidariedade à Rainha dos Baixinhos nas redes sociais. No Twitter e no Instagram, diversas pessoas enviaram mensagens de força para a apresentadora, que vinha levando ao público o estado de saúde delicado da mãe. &#8220;Se pudesse, daria alguns anos da minha vida para vê-la sem dor&#8221;, disse Xuxa em um vídeo postado em seu Instagram no início deste ano.</p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/entretenimento/xuxa-faz-homenagem-a-mae-nas-redes-meu-passarinho-voou/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2017/12/entretenimento-xuxa-mae.jpg" length="48000000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2017/12/entretenimento-xuxa-mae.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2017/12/entretenimento-xuxa-mae.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Morre Alda Meneghel, mãe de Xuxa</media:title>
		</media:content>

		<media:content url="http://1.gravatar.com/avatar/7f7aedd573c78a806b23a6f0e2ad2e2f?s=96&#38;d=https%3A%2F%2F1.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">mcarolinamaia</media:title>
		</media:content>
	</item>
		<item>
		<title>‘O Outro Lado’: O arco dramático de Gael, de pastel a desafiante da morte</title>
		<link>https://veja.abril.com.br/entretenimento/o-outro-lado-o-arco-dramatico-de-gael-de-pastel-a-desafiante-da-morte/</link>
		<comments>https://veja.abril.com.br/entretenimento/o-outro-lado-o-arco-dramatico-de-gael-de-pastel-a-desafiante-da-morte/#respond</comments>
		<pubDate>Tue, 08 May 2018 15:56:23 +0000</pubDate>
		<dc:creator><![CDATA[Maria Carolina Maia]]></dc:creator>
				<category><![CDATA[Entretenimento]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525670</guid>
		<description><![CDATA[Personagem rouba as barras de ouro ilegais da própria mãe e se coloca diante do vilão Renato, sequestrador armado de Tomaz, na tentativa de salvar o filho]]></description>
				<content:encoded><![CDATA[<p><strong>Gael</strong>, o playboy vivido por Sérgio Guizé em <strong><i>O Outro Lado do Paraíso</i></strong>, era tão covarde que batia em mulher para se sentir forte e, mesmo depois de descobrir as mãos sujas de sangue da mãe, só saiu de casa quando a própria o pôs para fora. Mas, nesta terça-feira, em uma missão que parece impossível, Gael vai começar a se despir da pele oleosa de pastel na <strong>novela das 9</strong> da <strong>Globo</strong>.</p>
<p>A coragem de Gael vai aparecer quando ele detalhar o plano elaborado para libertar o filho, Tomaz (Vitor Figueiredo), do casamento com a mocinha, Clara (Bianca Bin), de quem abusou e a quem espancou no início do folhetim de Walcyr Carrasco. Gael pretende pagar o resgate ao vilão Renato (Rafael Cardoso), personagem que foi do Jekyll ao Hyde ao se revelar vilão, com barras de ouro ilegais que a mãe megera, Sophia (Marieta Severo), esconde em casa – ele deu uma passadinha na mansão, no capítulo desta segunda, para conferir se elas estavam por lá.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/entretenimento">Entretenimento</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/entretenimento/o-outro-lado-do-paraiso-gael-o-pastel/">‘O Outro Lado do Paraíso’: Gael, o pastel</a></span><span class="widget-news-item-date">2 maio 2018 - 12h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/entretenimento">Entretenimento</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/entretenimento/vote-clara-deve-terminar-o-outro-lado-do-paraiso-pobre-ou-rica/">Clara rica, Clara pobre: como a mocinha deve terminar em &#8216;O Outro Lado&#8217;?</a></span><span class="widget-news-item-date">3 maio 2018 - 09h05</span></div></li></ul></div>
<p>As barras não precisam alcançar juntas o valor absurdo de 100 milhões de dólares pedido pelo médico descompensado. Pelo contrário: a ideia é que Renato não fique com uma barrinha sequer, e que termine preso. A armadilha deve contar com a participação do sempre diligente delegado Bruno (Caio Paduan).</p>
<p>Mas, no cerco ao médico e sua atual esposa, Fabiana (Fernanda Rodrigues), Gael vai acabar se vendo frente a frente com o revólver de Renato. E com a morte.</p>
<p>Fim do arco dramático. Enfim, uma metamorfose interessante em uma novela em que, a cada vingança executada por Clara, seu alvo se torna uma caricatura ambulante. Como o fraco Renato.</p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/entretenimento/o-outro-lado-o-arco-dramatico-de-gael-de-pastel-a-desafiante-da-morte/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2018/05/gael_reloaded.jpg" length="3000000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2018/05/gael_reloaded.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2018/05/gael_reloaded.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">gael_reloaded</media:title>
		</media:content>

		<media:content url="http://1.gravatar.com/avatar/7f7aedd573c78a806b23a6f0e2ad2e2f?s=96&#38;d=https%3A%2F%2F1.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">mcarolinamaia</media:title>
		</media:content>
	</item>
		<item>
		<title>Joaquim Barbosa sempre esteve em dúvida, diz presidente do PSB</title>
		<link>https://veja.abril.com.br/politica/joaquim-barbosa-sempre-esteve-em-duvida-diz-presidente-do-psb/</link>
		<comments>https://veja.abril.com.br/politica/joaquim-barbosa-sempre-esteve-em-duvida-diz-presidente-do-psb/#respond</comments>
		<pubDate>Tue, 08 May 2018 15:45:06 +0000</pubDate>
		<dc:creator><![CDATA[Estadão Conteúdo]]></dc:creator>
				<category><![CDATA[Política]]></category>
		<category><![CDATA[Joaquim Barbosa]]></category>
		<category><![CDATA[Márcio França]]></category>
		<category><![CDATA[PSB]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525439</guid>
		<description><![CDATA[Carlos Siqueira afirmou que reuniões para disputa haviam começado mas que não existia o compromisso, nem do ex-ministro nem do partido, pela candidatura]]></description>
				<content:encoded><![CDATA[<p>O presidente nacional do <a href="https://veja.abril.com.br/noticias-sobre/psb"><strong>PSB</strong></a>, <strong>Carlos Siqueira</strong>, disse nesta terça-feira, 8, ser &#8220;compreensível&#8221; a decisão do ex-ministro do STF <a href="https://veja.abril.com.br/noticias-sobre/joaquim-barbosa"><strong>Joaquim Barbosa</strong></a> de não ser candidato à Presidência da República pelo partido nas eleições deste ano. De acordo com Siqueira, &#8220;essa dúvida [de disputar ou não o Planalto] ele sempre teve&#8221; e a decisão não foi &#8220;uma surpresa&#8221;.</p>
<p>&#8220;Nós nunca asseguramos a legenda para ele, assim como ele nunca assegurou para nós que seria candidato. Então, estava dentro do combinado&#8221;, comentou. O presidente do PSB afirmou que Barbosa o avisou nesta manhã, por telefone, dizendo &#8220;que refletiu muito e que tinha decidido não ser&#8221;.</p>
<p>O ex-presidente do STF alegou, diz, questões pessoais para não disputar. &#8220;Disse a ele que era compreensível, porque é uma decisão de foro muito íntimo ser ou não candidato em uma eleição&#8221;, completou.</p>
<p>Carlos Siqueira contou que, na semana passada, ele havia se reunido com Barbosa para acertar a contratação de assessores e o agendamento de encontros com economistas e especialistas na área social para discussão de um futuro plano de governo. &#8220;Tomamos uma série de decisões, mas ele recuou&#8221;, declarou.</p>
<p>O presidente disse que o partido vai discutir o que fazer a partir de agora nas próximas semanas. &#8220;Vamos discutir esse assunto posteriormente&#8221;, declarou. A VEJA, o governador de São Paulo, <a href="https://veja.abril.com.br/noticias-sobre/marcio-franca"><strong>Márcio França</strong></a>, afirmou que o indicativo atual é o de que <a href="https://veja.abril.com.br/politica/e-preciso-respeitar-a-vocacao-das-pessoas-diz-franca-sobre-barbosa/">o PSB não tenha candidato</a>.</p>
<p>“A candidatura do ministro Joaquim, um nome forte e respeitado, era honrosa para o PSB. Agora, acredito que a tendência é não ter candidato, o que é sempre mais fácil, mas ainda vamos discutir esse assunto”, afirmou.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/politica">Política</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/blog/radar/joaquim-barbosa-desiste-de-candidatura-a-presidencia/">Joaquim Barbosa desiste de candidatura à Presidência</a></span><span class="widget-news-item-date">8 maio 2018 - 10h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/politica">Política</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/politica/e-preciso-respeitar-a-vocacao-das-pessoas-diz-franca-sobre-barbosa/">&#8216;É preciso respeitar a vocação das pessoas&#8217;, diz França sobre Barbosa</a></span><span class="widget-news-item-date">8 maio 2018 - 11h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/politica">Política</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/blog/radar/bolsonaro-nega-surpresa-com-decisao-de-barbosa-mas-agradece-desistencia/">Bolsonaro nega surpresa com decisão de Barbosa, mas agradece desistência</a></span><span class="widget-news-item-date">8 maio 2018 - 11h05</span></div></li></ul></div>
<p>França integra uma ala que defende uma aliança com Geraldo Alckmin (PSDB), enquanto diretórios da região nordeste simpatizam com candidaturas mais à esquerda, como Ciro Gomes (PDT) ou o nome que será apresentado pelo PT. A neutralidade, nesse caso, poderia ser a saída para evitar uma ampliação das divergências partidárias.</p>
<p>Após meses de especulações e articulações de bastidores, Barbosa anunciou sua decisão de não disputar o pleito deste ano em sua conta no Twitter. &#8220;Está decidido. Após várias semanas de muita reflexão, finalmente cheguei a uma conclusão. Não pretendo ser candidato a Presidente da República&#8221;, escreveu o ex-ministro, que havia se filiado ao PSB no começo de abril.</p>
<p><em>(Com Estadão Conteúdo)</em></p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/politica/joaquim-barbosa-sempre-esteve-em-duvida-diz-presidente-do-psb/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2016/12/carlos-siqueira.jpg" length="3125200" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2016/12/carlos-siqueira.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2016/12/carlos-siqueira.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Carlos Siqueira</media:title>
		</media:content>

		<media:content url="http://1.gravatar.com/avatar/76fc2215beda2e1c0873dfe58e86efdf?s=96&#38;d=https%3A%2F%2F1.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">wpestadao</media:title>
		</media:content>
	</item>
		<item>
		<title>Mourinho admite sonegação e é multado em 800.000 euros</title>
		<link>https://veja.abril.com.br/esporte/mourinho-admite-sonegacao-e-e-multado-em-800-000-euros/</link>
		<comments>https://veja.abril.com.br/esporte/mourinho-admite-sonegacao-e-e-multado-em-800-000-euros/#respond</comments>
		<pubDate>Tue, 08 May 2018 15:40:08 +0000</pubDate>
		<dc:creator><![CDATA[EFE]]></dc:creator>
				<category><![CDATA[Esporte]]></category>
		<category><![CDATA[Placar]]></category>
		<category><![CDATA[Futebol Europeu]]></category>
		<category><![CDATA[José Mourinho]]></category>
		<category><![CDATA[Liga dos Campeões da Europa]]></category>
		<category><![CDATA[Manchester United]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525593</guid>
		<description><![CDATA[Treinador português propôs acordo que foi aceito pela Justiça da Espanha]]></description>
				<content:encoded><![CDATA[<p>O técnico português <a href="https://veja.abril.com.br/noticias-sobre/jose-mourinho/"><strong>José Mourinho</strong></a>, do<a href="https://veja.abril.com.br/noticias-sobre/manchester-united/"><strong> Manchester United</strong></a>, chegou a um acordo verbal com o <strong>Ministério Público da Espanha</strong>, em que se declarou culpado por dois crimes contra a Receita e se comprometeu a pagar 800 mil euros de multa (cerca de 3,38 milhões de reis).</p>
<p>Fontes ligadas ao processo relataram que a defesa do ex-treinador do Real Madrid enviou carta à Promotoria, há alguns dias, propondo os termos que foram aceitos pela Justiça, conforme publicou nesta terça-feira o jornal espanhol <em><a href="http://www.elmundo.es/deportes/football-leaks/2018/05/08/5af0a64246163fed358b4606.html">El Mundo</a></em>.</p>
<p>O Tribunal de Instrução número 4 de Alarcón, em Madri, investigava Mourinho, a partir de denúncia apresentada pelo Setor de Crimes Financeiros da Promotoria da capital, de fraude de 3,3 milhões de euros (13,9 milhões de reais), durante passagem pelo Real Madrid, entre 2011 e 2012.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/esporte">Esporte</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/esporte/zagueiro-frances-koscielny-e-operado-e-esta-fora-da-copa-do-mundo/">Zagueiro francês Koscielny é operado e está fora da Copa do Mundo</a></span><span class="widget-news-item-date">8 maio 2018 - 10h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/esporte">Esporte</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/esporte/thiago-motta-do-psg-anuncia-aposentadoria-aos-35-anos/">Thiago Motta, do PSG, anuncia aposentadoria aos 35 anos</a></span><span class="widget-news-item-date">8 maio 2018 - 09h05</span></div></li></ul></div>
<p>O português foi acusado por dois crimes de sonegação ao Imposto de Renda. A Receita confirmou a Promotoria que o técnico assinou contrato, cedendo os direitos de imagem a uma empresa com sede nas Ilhas Virgens Britânicas, depois passando para outras sociedades. De acordo com a denúncia, a ideia era ocultar os valores recebidos a título de direitos de imagem.</p>
<p>&nbsp;</p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/esporte/mourinho-admite-sonegacao-e-e-multado-em-800-000-euros/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2016/09/mourinho.jpg" length="6750000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2016/09/mourinho.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2016/09/mourinho.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Técnico José Mourinho durante coletiva de imprensa</media:title>
		</media:content>

		<media:content url="http://1.gravatar.com/avatar/7c89f05f74936e5a0a05a29d0f9c7556?s=96&#38;d=https%3A%2F%2F1.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">wpagenciaefe</media:title>
		</media:content>
	</item>
		<item>
		<title>Pai é preso acusado de estupro após filha relatar abuso em bilhete</title>
		<link>https://veja.abril.com.br/brasil/pai-e-preso-acusado-de-estupro-apos-filha-relatar-abuso-em-bilhete/</link>
		<comments>https://veja.abril.com.br/brasil/pai-e-preso-acusado-de-estupro-apos-filha-relatar-abuso-em-bilhete/#respond</comments>
		<pubDate>Tue, 08 May 2018 15:39:30 +0000</pubDate>
		<dc:creator><![CDATA[Estadão Conteúdo]]></dc:creator>
				<category><![CDATA[Brasil]]></category>
		<category><![CDATA[Criança]]></category>
		<category><![CDATA[Crime]]></category>
		<category><![CDATA[Estupro]]></category>
		<category><![CDATA[São Paulo]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2524796</guid>
		<description><![CDATA[Criança de onze anos entregou mensagem com denúncia a uma colega de escola; caso aconteceu em Paulínia (SP)]]></description>
				<content:encoded><![CDATA[<p>Um bilhete escrito por uma menina de onze anos, entregue a uma colega de escola, levou à prisão de um homem suspeito de estuprar as três filhas menores, em Paulínia, interior de São Paulo. &#8220;Eu sofro abuso do meu pai&#8221;, escreveu a criança a lápis, num pedaço de papel, juntando à frase um desenho indicando tristeza. O bilhete foi parar nas mãos do motorista da van escolar usada pela estudante, que o entregou à<strong> Polícia Civil</strong>. O vigilante José Maria Rodrigues Pinheiro, de 56 anos, pai da menina, foi preso na última sexta-feira (4).</p>
<p>Os detalhes do caso só foram revelados nesta segunda-feira pelo delegado <strong>Rodrigo Galazzo</strong>, depois que os exames confirmaram que a menina teve o hímen rompido. De acordo com ele, as outras duas filhas, de dez e doze anos, também denunciaram os<strong> <a href="https://veja.abril.com.br/noticias-sobre/abuso-sexual/">abusos</a></strong> que vinham sendo praticados pelo pai há pelo menos um ano.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/brasil">Brasil</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/brasil/denuncias-de-estupro-cresceram-4-no-rj-em-2017/">Denúncias de estupro cresceram 4% no RJ em 2017</a></span><span class="widget-news-item-date">4 maio 2018 - 18h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/brasil">Brasil</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/brasil/pf-faz-operacao-nacional-contra-pedofilia-e-prende-18-pessoas/">PF faz operação nacional contra pedofilia e prende 18 pessoas</a></span><span class="widget-news-item-date">26 abr 2018 - 07h04</span></div></li></ul></div>
<p>Segundo o delegado, o homem negou a acusação de estupro, mas admitiu que acariciava as filhas. Ainda conforme Galazzo, além do exame médico, os depoimentos das meninas, acompanhados pelo Conselho Tutelar, confirmam os abusos.</p>
<p>De acordo com o policial, a mãe das crianças desconhecia a situação, por isso continuará na guarda das menores, que serão acompanhadas pelo <a href="https://veja.abril.com.br/noticias-sobre/conselho-tutelar/">Conselho Tutelar</a>. As meninas já estão tendo atendimento psicológico. Pinheiro teve a prisão temporária decretada por 30 dias, mas o delegado vai pedir a conversão em prisão preventiva (sem prazo). O homem foi levado para uma cadeia pública na região de Campinas e, segundo a polícia, ainda não tem advogado de defesa.</p>
<p><em>(Com Estadão Conteúdo)</em></p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/brasil/pai-e-preso-acusado-de-estupro-apos-filha-relatar-abuso-em-bilhete/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2018/05/bilhete-abuso-infantil1.jpg" length="48000000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2018/05/bilhete-abuso-infantil1.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2018/05/bilhete-abuso-infantil1.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Bilhete de filha leva pai à prisão em Paulínia (SP)</media:title>
		</media:content>

		<media:content url="http://1.gravatar.com/avatar/76fc2215beda2e1c0873dfe58e86efdf?s=96&#38;d=https%3A%2F%2F1.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">wpestadao</media:title>
		</media:content>
	</item>
		<item>
		<title>Governo estuda ampliar programa Minha Casa Minha Vida</title>
		<link>https://veja.abril.com.br/economia/governo-estuda-ampliar-programa-minha-casa-minha-vida/</link>
		<comments>https://veja.abril.com.br/economia/governo-estuda-ampliar-programa-minha-casa-minha-vida/#respond</comments>
		<pubDate>Tue, 08 May 2018 15:22:52 +0000</pubDate>
		<dc:creator><![CDATA[Estadão Conteúdo]]></dc:creator>
				<category><![CDATA[Economia]]></category>
		<category><![CDATA[Caixa Econômica Federal]]></category>
		<category><![CDATA[casa]]></category>
		<category><![CDATA[Governo]]></category>
		<category><![CDATA[Minha Casa Minha Vida]]></category>
		<category><![CDATA[União]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2524854</guid>
		<description><![CDATA[A ideia é beneficiar famílias mais carentes, especialmente a faixa 1 - que têm renda familiar de até 1.800 reais]]></description>
				<content:encoded><![CDATA[<p>O <a href="https://veja.abril.com.br/noticias-sobre/governo/"><strong>governo</strong></a> estuda <strong>ampliar o programa habitacional <a href="https://veja.abril.com.br/noticias-sobre/minha-casa-minha-vida/">Minha Casa Minha Vida</a></strong><a href="https://veja.abril.com.br/noticias-sobre/minha-casa-minha-vida/"> (<strong>MCMV</strong>)</a> para famílias carentes. A iniciativa tenta dar ânimo ao setor da construção civil ao mesmo tempo em que dá uma resposta federal ao debate sobre habitação popular após o desabamento do edifício ocupado por famílias carentes no centro de <a href="https://veja.abril.com.br/noticias-sobre/sao-paulo/">São Paulo</a>. O estudo para ampliar o programa habitacional foi confirmado pelo presidente da <a href="https://veja.abril.com.br/noticias-sobre/caixa-economica-federal/">Caixa Econômica Federal</a>, Nelson Antônio de Souza. O tema é acompanhado de perto pelo presidente <a href="https://veja.abril.com.br/noticias-sobre/michel-temer/">Michel Temer</a>.</p>
<p>A ampliação do programa tende a ocorrer com o remanejamento de recursos e injeção de <a href="https://veja.abril.com.br/noticias-sobre/dinheiro/">dinheiro</a> do <a href="https://veja.abril.com.br/noticias-sobre/fgts/">Fundo de Garantia do Tempo de Serviço (FGTS)</a>. Segundo pessoas que acompanham o debate no governo, a ideia é beneficiar famílias mais carentes, especialmente a faixa 1 &#8211; que têm renda familiar de até 1.800 reais e pagam prestações mensais entre 80 reais e 270 reais por até 120 meses. Algumas das opções também contemplam a ampliação do número de casas da faixa 1,5 &#8211; com renda entre 1.800 reais e 2.600 reais, mas a prioridade são as famílias mais pobres.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/economia">Economia</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/economia/tcu-da-aval-para-governo-usar-dinheiro-de-fundo-para-cumprir-regra-de-ouro/">TCU dá aval para governo usar dinheiro de fundo para cumprir regra de ouro</a></span><span class="widget-news-item-date">2 maio 2018 - 17h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/economia">Economia</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/economia/em-busca-de-agenda-positiva-temer-anuncia-hoje-reajuste-do-bolsa-familia/">Governo anuncia reajuste de 5,67% no Bolsa Família</a></span><span class="widget-news-item-date">30 abr 2018 - 18h04</span></div></li></ul></div>
<p>O tema foi debatido nesta tarde de segunda-feira no <a href="https://veja.abril.com.br/noticias-sobre/ministerio-do-planejamento/">Ministério do Planejamento</a>, exatamente a pasta que administra imóveis da <a href="https://veja.abril.com.br/noticias-sobre/uniao/">União</a>, inclusive o edifício Wilton Paes de Almeida que foi consumido pelo fogo e desabou em São Paulo. A proposta é aumentar o número de famílias beneficiadas na base do MCMV. Em 2017, o governo contratou apenas 23.000 moradias destinadas a famílias que ganham até 1.800 reais. Isso representa apenas 13,5% da meta de 170.000 unidades para o ano.</p>
<p>Ao deixar reunião com o ministro da Fazenda, Eduardo Guardia, o presidente da Caixa confirmou os estudos. Segundo ele, o tema é analisado conjuntamente pelos ministérios das Cidades, Planejamento, Fazenda e a própria Caixa. Questionado sobre a perspectiva de benefício das famílias da faixa 1,5 &#8211; com renda entre 1.800 reais e 2.600 reais, Nelson Antônio de Souza disse que &#8220;não sei se vai chegar&#8221; a esse grupo intermediário.</p>
<p>&#8220;Tudo será feito de maneira bastante responsável. Essa é uma orientação do próprio presidente e da equipe econômica&#8221;, disse o presidente da Caixa. O modelo para a ampliação e a palavra final serão do próprio presidente Temer. Atualmente, o governo prevê 650.000 unidades habitacionais em 2018 para todas as faixas do MCMV que beneficia famílias com renda de até 7.000 reais.</p>
<p>Com o reforço do programa habitacional, o governo Temer tenta incentivar a atividade da construção civil, segmento que tem grande capacidade de geração de empregos. Ao mesmo tempo, seria uma maneira de Brasília reagir ao problema da habitação popular urbana que voltou ao centro do debate nacional após a tragédia no centro da capital paulista.</p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/economia/governo-estuda-ampliar-programa-minha-casa-minha-vida/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2017/02/minha-casa-minha-vida.jpg" length="12000000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2017/02/minha-casa-minha-vida.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2017/02/minha-casa-minha-vida.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Minha Casa, Minha Vida em Olinda - 7/5/2010</media:title>
		</media:content>

		<media:content url="http://1.gravatar.com/avatar/76fc2215beda2e1c0873dfe58e86efdf?s=96&#38;d=https%3A%2F%2F1.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">wpestadao</media:title>
		</media:content>
	</item>
		<item>
		<title>Nigéria liberta 1.000 sequestrados pelo Boko Haram</title>
		<link>https://veja.abril.com.br/mundo/nigeria-liberta-1-000-sequestrados-pelo-boko-haram/</link>
		<comments>https://veja.abril.com.br/mundo/nigeria-liberta-1-000-sequestrados-pelo-boko-haram/#respond</comments>
		<pubDate>Tue, 08 May 2018 15:15:54 +0000</pubDate>
		<dc:creator><![CDATA[Denise Chrispim Marin]]></dc:creator>
				<category><![CDATA[Mundo]]></category>
		<category><![CDATA[Boko Haram]]></category>
		<category><![CDATA[Exército]]></category>
		<category><![CDATA[Nigeria]]></category>
		<category><![CDATA[Sequestro]]></category>
		<category><![CDATA[Unicef]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525577</guid>
		<description><![CDATA[Grupo jihadista foi atacado por força militar multinacional; mais de 1.000 crianças foram sequestradas desde 2013, segundo Unicef ]]></description>
				<content:encoded><![CDATA[<p>O Exército da Nigéria libertou cerca de 1.000 pessoas dos campos do grupo jihadista <a href="https://veja.abril.com.br/noticias-sobre/boko-haram/"><strong>Boko Haram</strong></a> no nordeste do país. Entre os libertados estão mulheres, crianças e jovens forçados pelos <strong>jihadistas</strong> a entrar em suas fileiras, afirmou o porta-voz do Exército, Texas Chukwuma, nesta terça-feira (8).</p>
<p>A operação de resgate aconteceu graças à colaboração da força militar multinacional conjunta, formada em 2015 pela Nigéria, Camarões, Níger, Chade e Benin para combater a milícia islâmica em torno do <strong>Lago Chade</strong>.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/mundo">Mundo</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/mundo/boko-haram-ataca-mesquita-na-nigeria-e-mata-20-pessoas/">Boko Haram ataca mesquita na Nigéria e mata 20 pessoas</a></span><span class="widget-news-item-date">1 maio 2018 - 16h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/mundo">Mundo</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/mundo/nigeria-quer-transformar-esconderijo-do-boko-haram-em-atracao-turistica/">Nigéria quer tornar floresta refúgio do Boko Haram em atração turística</a></span><span class="widget-news-item-date">25 abr 2018 - 19h04</span></div></li></ul></div>
<p>O Boko Haram realiza frequentes sequestros na região, sobretudo de adolescentes, que são submetidos a casamento forçado, escravidão sexual e também a aderir ao grupo como combatentes. Em geral, são as pessoas a se sacrificar em ataques suicidas.</p>
<p>Mais de 1.000 crianças foram sequestradas no nordeste da Nigéria pelo Boko Haram desde 2013, publicou o <a href="https://veja.abril.com.br/noticias-sobre/unicef/"><strong>Fundo das Nações Unidas para a Infância (Unicef)</strong></a> no mês passado.</p>
<p>O sequestro em massa mais conhecido do grupo jihadista ocorreu em abril de 2014, quando foram levadas mais de 200 estudantes de um colégio em Chibok, no Estado de Borno. Mais de 100 delas foram liberadas, porém 112 permanecem em cativeiro.</p>
<p>No último dia 19 de fevereiro, o grupo realizou  outro sequestro em massa. Desta vez, de 113 alunas de uma escola de ensino médio de Dapchi, no Estado de Yobe. Apenas uma das meninas permanece em cativeiro.</p>
<p>O Boko Haram, que significa &#8220;a educação não-islâmica é pecado&#8221;, luta para impor uma corte islâmica na Nigéria, país de maioria muçulmana no norte e predominantemente cristã no sul. Mais de 20 mil pessoas morreram desde o início da insurgência jihadista na região, em 2009.</p>
<p><em>(Com EFE)</em></p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/mundo/nigeria-liberta-1-000-sequestrados-pelo-boko-haram/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2016/06/imagens-do-dia-20141002-73-original3.jpeg" length="1731040" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2016/06/imagens-do-dia-20141002-73-original3.jpeg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2016/06/imagens-do-dia-20141002-73-original3.jpeg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">imagens-do-dia-20141002-73-original.jpeg</media:title>
		</media:content>

		<media:content url="http://0.gravatar.com/avatar/3ba6da1e57db132297fbe62e38446e37?s=96&#38;d=https%3A%2F%2F0.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">denisechrispimmarin</media:title>
		</media:content>
	</item>
		<item>
		<title>Dólar é cotado a R$ 3,59 pressionado por cenário externo</title>
		<link>https://veja.abril.com.br/economia/dolar-e-cotado-a-r-359-pressionado-por-cenario-externo/</link>
		<comments>https://veja.abril.com.br/economia/dolar-e-cotado-a-r-359-pressionado-por-cenario-externo/#respond</comments>
		<pubDate>Tue, 08 May 2018 15:07:13 +0000</pubDate>
		<dc:creator><![CDATA[Fabiana Futema]]></dc:creator>
				<category><![CDATA[Economia]]></category>
		<category><![CDATA[Dólar]]></category>
		<category><![CDATA[Eleições]]></category>
		<category><![CDATA[Estados Unidos]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525572</guid>
		<description><![CDATA[Indefinição eleitoral no Brasil também contribui para alta da moeda americana]]></description>
				<content:encoded><![CDATA[<p>O<a href="https://veja.abril.com.br/noticias-sobre/dolar/"><strong> dólar</strong></a> opera em alta na manhã desta terça-feira, 9. A moeda americana é cotada a 3,59 reais, aguardando o anúncio da decisão do presidente americano, <a href="https://veja.abril.com.br/noticias-sobre/donald-trump/"><strong>Donald Trump</strong></a>, sobre a permanência no acordo nuclear com o Irã. Às 12h, a moeda avançava 0,93%. “O dólar segue tendência de alta e deve continuar subindo impactado por diversos fatores, tanto externos quanto internos”, diz o economista Sidnei Nehme, diretor executivo da NGO Corretora de Câmbio.</p>
<p>Entre esses motivos ele cita a expectativa de que os juros possam subir mais do que o esperado nos <a href="https://veja.abril.com.br/noticias-sobre/estados-unidos/"><strong>Estados Unidos</strong></a>. “Temos um cenário externo pressionado pela truculência política e econômica do presidente Trump”, diz Nehme.</p>
<p>Além disso, destaca o economista, temos um cenário interno bastante indefinido, especialmente do ponto de vista eleitoral.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/economia">Economia</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/economia/dolar-sobe-e-fecha-no-patamar-de-r-355-pela-1a-vez-em-quase-2-anos/">Dólar sobe e fecha no patamar de R$ 3,55 pela 1ª vez em quase 2 anos</a></span><span class="widget-news-item-date">7 maio 2018 - 18h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/economia">Economia</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/economia/dolar-sobe-e-volta-para-o-patamar-de-r-355-com-cena-externa/">Dólar sobe e volta para o patamar de R$ 3,55 com cena externa</a></span><span class="widget-news-item-date">7 maio 2018 - 13h05</span></div></li></ul></div>
<p>Nesta terça-feira, o ex-ministro do Supremo Tribunal Federal (STF), <a href="https://veja.abril.com.br/blog/radar/joaquim-barbosa-desiste-de-candidatura-a-presidencia/"><strong>Joaquim Barbosa</strong></a>, anunciou que não será candidato à Presidência da República. Para o Nehme, esse é mais um fator no já conturbado panorama interno, “com uma economia que não deslancha”, e que pressiona a cotação da moeda.</p>
<p>Ele cita que indicadores divulgados nesta terça-feira reforçam essa expectativa menos otimista. O Índice Geral de Preços – Disponibilidade Interna (IGP-DI) apresentou alta de 0,93% em abril, ante aumento de 0,56% em março, conforme a Fundação Getulio Vargas (FGV).</p>
<p>O indicador de Antecedente de Emprego, também divulgado nesta terça-feira pela FGV e que antecipa os dados do mercado de trabalho, registrou queda em abril, mostrando desaceleração no ritmo de recuperação do mercado de trabalho.</p>
<p>A projeção de Nehme é que o dólar atinja a marca de 3,75 reais com a proximidade das eleições.</p>
<p><span>O gerente de câmbio da Treviso, Reginaldo Galhardo, também considera que as incertezas em relação à economia aliadas ao cenário internacional, com a briga comercial entre Estados Unidos e China, por exemplo, e a expectativa de aumento na taxa de juros nos EUA contribuem para que a moeda americana siga se valorizando. </span></p>
<p><span>“No curto prazo a tendência é que o dólar siga em alta”, diz Galhardo.</span></p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/economia/dolar-e-cotado-a-r-359-pressionado-por-cenario-externo/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2016/07/alx_moeda_original-e1478801613991.jpeg" length="21360000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2016/07/alx_moeda_original-e1478801613991.jpeg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2016/07/alx_moeda_original-e1478801613991.jpeg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">alx_moeda_original.jpeg</media:title>
		</media:content>

		<media:content url="http://0.gravatar.com/avatar/f46f088f8805c9c8f2349e5bd70e6592?s=96&#38;d=https%3A%2F%2F0.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">fabifutema</media:title>
		</media:content>
	</item>
		<item>
		<title>Triunfo do Hezbollah é vitória contra Israel e EUA, diz Irã</title>
		<link>https://veja.abril.com.br/mundo/triunfo-do-hezbollah-no-libano-uma-vitoria-contra-israel-e-eua-diz-ira/</link>
		<comments>https://veja.abril.com.br/mundo/triunfo-do-hezbollah-no-libano-uma-vitoria-contra-israel-e-eua-diz-ira/#respond</comments>
		<pubDate>Tue, 08 May 2018 14:52:18 +0000</pubDate>
		<dc:creator><![CDATA[Carolina Marins]]></dc:creator>
				<category><![CDATA[Mundo]]></category>
		<category><![CDATA[Hezbollah]]></category>
		<category><![CDATA[Irã]]></category>
		<category><![CDATA[Líbano]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525362</guid>
		<description><![CDATA[Resultados extraoficiais mostram o grupo xiita ganhando mais da metade das cadeiras do parlamento; Hariri deve se manter como primeiro-ministro]]></description>
				<content:encoded><![CDATA[<p>O apoio popular ao movimento xiita <a href="https://veja.abril.com.br/noticias-sobre/Hezbollah/"><strong>Hezbollah</strong> </a>nas eleições legislativas do <a href="https://veja.abril.com.br/noticias-sobre/libano/"><strong>Líbano</strong> </a>é um êxito na luta contra <a href="https://veja.abril.com.br/noticias-sobre/israel/"><strong>Israel</strong> </a>e <a href="https://veja.abril.com.br/noticias-sobre/estados-unidos/"><strong>Estados Unidos</strong></a>, declarou <strong>Ali Akbar Velayati</strong>, conselheiro diplomático do guia supremo do <a href="https://veja.abril.com.br/noticias-sobre/ira/"><strong>Irã</strong></a>, aitolá <strong>Ali Khamenei</strong>. Pesquisas preliminares mostram o grupo conquistando mais da metade das cadeiras. Porém, o resultado oficial ainda não foi divulgado.</p>
<p>&#8220;Esta vitória completa os êxitos militares. O povo libanês e seus representantes, ou seja, o Hezbollah e os outros grupos da resistência, triunfaram na luta contra Israel e seus aliados, em particular os Estados Unidos&#8221;, declarou Ali Akbar Velayati.</p>
<p>O porta-voz do aiatolá Khamenei considerou que o resultado eleitoral consagra a &#8220;vitória da ajuda determinante (do Irã) à <a href="https://veja.abril.com.br/noticias-sobre/siria/"><strong>Síria</strong> </a>ante os terroristas&#8221;. &#8220;Esta vitória do povo libanês e da resistência é uma aprovação da política do governo libanês para preservar a independência do Líbano ante Israel&#8221;, disse Velayati.</p>
<p>&#8220;O peso da Frente da Resistência será consideravelmente reforçado no mundo após a vitória do Hezbollah&#8221;, completou. No vocabulário do governo iraniano, a Frente da Resistência designa Irã, Síria, <a href="https://veja.abril.com.br/noticias-sobre/iraque/"><strong>Iraque</strong></a>, Hezbollah e os grupos palestinos próximos ao Irã.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/mundo">Mundo</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/mundo/hezbollah-vence-eleicao-parlamentar-no-libano/">Hezbollah vence eleição parlamentar no Líbano</a></span><span class="widget-news-item-date">7 maio 2018 - 15h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/mundo">Mundo</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/mundo/equipe-de-trump-contratou-firma-de-espionagem-para-minar-acordo-com-ira/">Equipe de Trump contratou firma de espionagem para minar acordo com Irã</a></span><span class="widget-news-item-date">7 maio 2018 - 13h05</span></div></li></ul></div>
<p>Os resultados extraoficiais apontam para a conquista de 67 das 128 cadeiras pelo Hezbollah e seus aliados, entre os quais o movimento Amal. Mas, segundo o jornal <i>Financial Times</i>, o grupo xiita não alcançou os dois terços necessários para realizar reformas constitucionais. Entre elas, as divisões sectárias no Poder Legislativo, que destinam metade das cadeiras aos cristãos maronitas e a outra metade, para os muçulmanos.</p>
<p>O primeiro-ministro, Saad Hariri, deverá ser reconduzido pelo bloco sunita que, embora tenha perdido cadeiras na Assembleia Nacional, continua  responsável pela designação para o cargo.</p>
<p>A eleição de domingo, a primeira desde 2009, foi marcada por grandes abstenção e protestos. Manifestantes protestaram em frente ao Ministério do Interior do Líbano, no centro de Beirute, contra supostas fraudes nas eleições. A candidata Yumana Haddad, do partido independente Kuluna Watani (Todos pela Pátria), afirmou ter perdido sua vaga no parlamento porque algumas urnas teriam sido extraviadas.</p>
<p>O Ministério do Interior contestou as informações, afirmando que só se pronunciará quando os resultados oficiais forem divulgados pelas autoridades responsáveis. Por esse mesmo motivo, o órgão disse não poder falar sobre o caso de Yumana Haddad.</p>
<p><em>(Com AFP e EFE)</em></p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/mundo/triunfo-do-hezbollah-no-libano-uma-vitoria-contra-israel-e-eua-diz-ira/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2018/05/ali-akbar-velayati-20180503-001.jpg" length="48000000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2018/05/ali-akbar-velayati-20180503-001.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2018/05/ali-akbar-velayati-20180503-001.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Ali Akbar Velayati</media:title>
		</media:content>

		<media:content url="http://0.gravatar.com/avatar/348d358af5b8d6bb75e4a5af9fe789ae?s=96&#38;d=https%3A%2F%2F0.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">a67893</media:title>
		</media:content>
	</item>
		<item>
		<title>Maioria dos americanos não quer saída dos EUA de acordo com o Irã</title>
		<link>https://veja.abril.com.br/mundo/maioria-dos-americanos-nao-quer-saida-dos-eua-de-acordo-com-o-ira/</link>
		<comments>https://veja.abril.com.br/mundo/maioria-dos-americanos-nao-quer-saida-dos-eua-de-acordo-com-o-ira/#respond</comments>
		<pubDate>Tue, 08 May 2018 14:45:24 +0000</pubDate>
		<dc:creator><![CDATA[Denise Chrispim Marin]]></dc:creator>
				<category><![CDATA[Mundo]]></category>
		<category><![CDATA[Barack Obama]]></category>
		<category><![CDATA[Donald Trump]]></category>
		<category><![CDATA[Energia nuclear]]></category>
		<category><![CDATA[Estados Unidos]]></category>
		<category><![CDATA[Irã]]></category>
		<category><![CDATA[Pesquisa]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525377</guid>
		<description><![CDATA[Pesquisa CNN/SSRS aponta o Irã em terceiro lugar entre as fontes de grave ameaça aos Estados Unidos; Exército Islâmico e Coreia do Norte estão na frente]]></description>
				<content:encoded><![CDATA[<div class="pg-right-rail-tall pg-wrapper ">
<article class="pg-rail-tall pg-rail--align-right ">
<div class="l-container">
<div class="pg-rail-tall__wrapper">
<div class="pg-side-of-rail pg-rail-tall__side">
<div class="pg-rail-tall__body">
<section id="body-text" class="zn zn-body-text zn-body zn--idx-0 zn--ordinary zn-has-multiple-containers zn-has-22-containers">
<div class="l-container">
<div class="el__leafmedia el__leafmedia--sourced-paragraph">
<p>Dois terços dos americanos (63%) não querem os <a href="https://veja.abril.com.br/noticias-sobre/estados-unidos"><strong>Estados Unidos</strong></a> fora do <strong>acordo nuclear</strong> com o <a href="https://veja.abril.com.br/noticias-sobre/ira/"><strong>Irã</strong></a>, registrou pesquisa de opinião da SSRS encomendada pela rede de televisão CNN. Apenas 29% dos entrevistados acreditam que <a href="https://veja.abril.com.br/noticias-sobre/washington/"><strong>Washington</strong></a> deva se retirar do acerto, firmado em 2015, que impede a continuidade do programa atômico militar iraniano.</p>
<p>Maioria similar, de 62%, acredita que o Irã tem violado os termos do acordo. Apenas 19% dos entrevistados não acredita nessa hipótese, e igual porcentual não têm opinião sobre o tema.</p>
<p>Os resultados da pesquisa foram divulgados hoje (8) pela CNN, quando se espera o anúncio do presidente dos Estados Unidos, <a href="https://veja.abril.com.br/noticias-sobre/donald-trump/"><strong>Donald Trump</strong></a>, sobre a permanência de seu país no acordo às 15h, no horário de Brasília. A possível retirada seria marcada também pelo retorno das sanções econômicas unilaterais de Washington ao Irã.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/mundo">Mundo</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/mundo/trump-deve-anunciar-decisao-sobre-acordo-nuclear-com-ira-nesta-terca/">Trump deve anunciar decisão sobre acordo nuclear com Irã nesta terça</a></span><span class="widget-news-item-date">7 maio 2018 - 17h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/mundo">Mundo</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/mundo/equipe-de-trump-contratou-firma-de-espionagem-para-minar-acordo-com-ira/">Equipe de Trump contratou firma de espionagem para minar acordo com Irã</a></span><span class="widget-news-item-date">7 maio 2018 - 13h05</span></div></li></ul></div>
<p>Trump tem classificado o acordo com o Irã, uma das heranças do governo democrata de <strong>Barack Obama</strong>, como &#8220;terrível ridículo&#8221;. Na semana passada, os líderes da França, Alemanha e Reino Unido, todos signatários junto com a China e Japão, tentaram demover Trump de levar adiante suas ameaças contra o Irã.</p>
<p>Os apelos das Nações Unidas para que os Estados Unidos se mantenham no acordo tampouco deverão ser considerados.  O presidente americano, que se dera prazo até 12 de maio para divulgar sua decisão, a antecipou para hoje.</p>
<p>A pesquisa CNN/SSRS mostra que os defensores da saída dos Estados Unidos do acordo foram potenciais eleitores de Trump. Entre os entrevistados que se declararam filiados ao Partido Republicano, 51% apoiam a saída. O porcentual cai a 47% entre os que se dizem apenas conservadores, e para 47% entre os que aprovam o governo de Trump.</p>
<p>A SSRS realizou entrevistas por telefone entre os dias 2 e 5 de maio com 1.015 adultos, em inglês e espanhol.  Dos entrevistados, 29% se descreveram como Democratas e 24%, como Republicanos. Independentes e membros de outros partidos somaram 47%.</p>
<p>A pesquisa aponta ainda que os americanos consideram o Exército Islâmico (EI) e outros grupos extremistas como as ameaças mais graves aos Estados Unidos. Entre os entrevistados, 59% deu essa opinião. A segunda maior fonte de ameaças é a Coreia do Norte (47%), seguida pelo Irã em terceiro lugar (40%). A Rússia vem em quarta posição (38%), e a China é quinta (25%).</p>
<p>A percepção piorou sobre o Irã desde a pesquisa anterior, de outubro, na qual 30% dos entrevistas consideravam esse país como grave ameaça. Mas vem caindo gradualmente no caso do Exército Islâmico, que alcançou 73% em maio de 2016.</p>
</div>
</div>
<div>
<div></div>
</div>
</section>
</div>
</div>
</div>
</div>
</article>
</div>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/mundo/maioria-dos-americanos-nao-quer-saida-dos-eua-de-acordo-com-o-ira/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2018/05/mundo-donald-trump-20180503-0001.jpg" length="6750000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2018/05/mundo-donald-trump-20180503-0001.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2018/05/mundo-donald-trump-20180503-0001.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Presidente dos Estados Unidos, Donald Trump</media:title>
		</media:content>

		<media:content url="http://0.gravatar.com/avatar/3ba6da1e57db132297fbe62e38446e37?s=96&#38;d=https%3A%2F%2F0.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">denisechrispimmarin</media:title>
		</media:content>
	</item>
		<item>
		<title>Morre Alda Meneghel, mãe de Xuxa, aos 81 anos</title>
		<link>https://veja.abril.com.br/entretenimento/morre-alda-meneghel-mae-de-xuxa-aos-81-anos/</link>
		<comments>https://veja.abril.com.br/entretenimento/morre-alda-meneghel-mae-de-xuxa-aos-81-anos/#respond</comments>
		<pubDate>Tue, 08 May 2018 14:39:29 +0000</pubDate>
		<dc:creator><![CDATA[Maria Carolina Maia]]></dc:creator>
				<category><![CDATA[Entretenimento]]></category>
		<category><![CDATA[Morte]]></category>
		<category><![CDATA[Obituário]]></category>
		<category><![CDATA[Xuxa]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525525</guid>
		<description><![CDATA[Mãe da apresentadora sofria de Mal de Parkinson e estava com a saúde bastante fragilizada nos últimos dias]]></description>
				<content:encoded><![CDATA[<p>Diagnosticada há mais de dez anos com <strong>Parkinson</strong>, e com a saúde muito debilitada nos últimos dias, <strong>Alda Meneghel</strong>, mãe da apresentadora <a href="https://veja.abril.com.br/noticias-sobre/xuxa"><strong>Xuxa</strong></a>, morreu aos 81 anos. Ainda não há detalhes sobre a causa e o local da morte.</p>
<p>Quatro dias atrás, Xuxa publicou um pedido nas redes sociais: que os fãs fizessem orações pela mãe, que passava por um momento difícil. &#8220;P<span>eço a vocês que têm muita fé que rezem por minha guerreira, minha <strong>Aldinha</strong>&#8220;, escreveu. No dia seguinte, fez um novo post, dizendo que a mãe havia melhorado um pouco. Não escreveu mais, desde então.</span></p>
<p>A luta de Alda contra o Parkinson, doença degenerativa que opera de modo incessante, é antiga e vinha se acentuando. Além do Parkinson em estágio avançado, Alda carregava as marcas de dois Acidentes Vasculares Cerebrais (AVC) sofridos m 2016.</p>
<p>Em janeiro, Xuxa usou as mesmas redes sociais para um desabafo.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/entretenimento">Entretenimento</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/entretenimento/xuxa-desabafa-sobre-mae-ha-anos-que-eu-peco-um-milagre/">Xuxa desabafa sobre mãe: &#8216;Há anos que eu peço um milagre&#8217;</a></span><span class="widget-news-item-date">26 jan 2018 - 16h01</span></div></li></ul></div>
<p><span>“Tem alguns anos que minha Aldinha não pode mais nos beijar ou abraçar… Tem alguns anos que a minha guerreira tá fazendo de tudo pra ficar aqui com a gente… Tem alguns anos que eu me pergunto por que ela sofre tanto, já que só deu amor pra quem a conheceu…. Tem alguns tantos anos que eu me pergunto o que eu fiz pra merecer a melhor mãe do mundo? Tem alguns anos que eu peço um milagre. Te amo e se pudesse daria alguns anos da minha vida pra vê-la sem dor, falando, abraçando… cantando um pequenino grão de areia”, escreveu.</span></p>
<p>Há cerca de um ano, a <a href="https://veja.abril.com.br/entretenimento/morre-floriano-meneghel-pai-de-xuxa/">apresentadora perdeu o pai, </a><strong><a href="https://veja.abril.com.br/entretenimento/morre-floriano-meneghel-pai-de-xuxa/">Floriano</a> Meneghel</strong>, de <span>falência múltipla de órgãos após uma prolongada internação hospitalar.</span></p>
<figure><img src="https://abrilveja.files.wordpress.com/2018/05/entretenimento-mae-xuxa-alda-20180508-002.jpg" /><figcaption>Alda Meneghel, mãe da apresentadora Xuxa<span class="copyright">Instagram</span></figcaption></figure>
<figure><img src="https://abrilveja.files.wordpress.com/2018/05/entretenimento-mae-xuxa-alda-20180508-001.jpg" /><figcaption>Alda Meneghel, mãe da apresentadora Xuxa<span class="copyright">Instagram</span></figcaption></figure>
<figure><img src="https://abrilveja.files.wordpress.com/2018/05/entretenimento-mae-xuxa-alda-20180508-006.jpg" /><figcaption>Alda Meneghel, mãe da apresentadora Xuxa<span class="copyright">Instagram</span></figcaption></figure>
<figure><img src="https://abrilveja.files.wordpress.com/2018/05/entretenimento-mae-xuxa-alda-20180508-005.jpg" /><figcaption>Alda Meneghel, mãe da apresentadora Xuxa<span class="copyright">Instagram</span></figcaption></figure>
<p>&nbsp;</p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/entretenimento/morre-alda-meneghel-mae-de-xuxa-aos-81-anos/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2018/05/entretenimento-mae-xuxa-alda-20180508-002.jpg" length="48000000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2018/05/entretenimento-mae-xuxa-alda-20180508-002.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2018/05/entretenimento-mae-xuxa-alda-20180508-002.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Alda Meneghel, mãe da apresentadora Xuxa</media:title>
		</media:content>

		<media:content url="http://1.gravatar.com/avatar/7f7aedd573c78a806b23a6f0e2ad2e2f?s=96&#38;d=https%3A%2F%2F1.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">mcarolinamaia</media:title>
		</media:content>

		<media:content url="http://abrilveja.files.wordpress.com/2018/05/entretenimento-mae-xuxa-alda-20180508-002.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Alda Meneghel, mãe da apresentadora Xuxa</media:title>
		</media:content>

		<media:content url="http://abrilveja.files.wordpress.com/2018/05/entretenimento-mae-xuxa-alda-20180508-001.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Alda Meneghel, mãe da apresentadora Xuxa</media:title>
		</media:content>

		<media:content url="http://abrilveja.files.wordpress.com/2018/05/entretenimento-mae-xuxa-alda-20180508-006.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Alda Meneghel, mãe da apresentadora Xuxa</media:title>
		</media:content>

		<media:content url="http://abrilveja.files.wordpress.com/2018/05/entretenimento-mae-xuxa-alda-20180508-005.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Alda Meneghel, mãe da apresentadora Xuxa</media:title>
		</media:content>
	</item>
		<item>
		<title>Bolsonaro é o único ausente em evento com presidenciáveis no RJ</title>
		<link>https://veja.abril.com.br/politica/bolsonaro-e-o-unico-ausente-em-evento-com-presidenciaveis-no-rj/</link>
		<comments>https://veja.abril.com.br/politica/bolsonaro-e-o-unico-ausente-em-evento-com-presidenciaveis-no-rj/#respond</comments>
		<pubDate>Tue, 08 May 2018 14:35:32 +0000</pubDate>
		<dc:creator><![CDATA[Estadão Conteúdo]]></dc:creator>
				<category><![CDATA[Política]]></category>
		<category><![CDATA[Eleições 2018]]></category>
		<category><![CDATA[Jair Bolsonaro]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525318</guid>
		<description><![CDATA[Pré-candidato do PSL não respondeu ao convite e, por meio de assessoria, disse que não poderia faltar à sessão da Câmara]]></description>
				<content:encoded><![CDATA[<p>O pré-candidato do PSL à Presidência da República, deputado federal <a href="https://veja.abril.com.br/noticias-sobre/jair-bolsonaro/"><strong> Jair Bolsonaro</strong></a>, é o único ausente nesta terça-feira, no &#8220;Diálogo com Presidenciáveis&#8221;, primeiro grande evento da corrida <a href="https://veja.abril.com.br/noticias-sobre/eleicoes-2018"><strong>eleitoral de 2018</strong></a>, que faz parte da programação da 73ª Reunião Geral da Frente Nacional de Prefeitos (FNP), em Niterói (RJ).</p>
<p>De acordo com a assessoria da prefeitura de Niterói, todos os pré-candidatos de partidos com mais de cinco deputados foram convidados, inclusive Bolsonaro. O deputado federal, porém, não respondeu ao convite. Questionada, a assessoria do parlamentar disse que o deputado negou porque ainda não se afastou do cargo e hoje é dia de sessão na Câmara. Se atendesse ao convite, o parlamentar &#8220;levaria falta&#8221;, acrescentou a assessoria.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/politica">Política</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/politica/ibope-sem-lula-alckmin-e-bolsonaro-empatam-em-sp/">Ibope: sem Lula, Alckmin e Bolsonaro empatam em SP</a></span><span class="widget-news-item-date">25 abr 2018 - 07h04</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/politica">Política</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/blog/radar/sem-lula-bolsonaro-lidera-e-joaquim-empata-em-2o-com-marina/">Sem Lula, Bolsonaro lidera e Joaquim empata com Marina em 2º</a></span><span class="widget-news-item-date">3 maio 2018 - 06h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/politica">Política</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/politica/bolsonaro-critica-pgr-por-denuncia-de-racismo-durante-entrevista-a-tv/">Bolsonaro critica PGR por denúncia de racismo durante entrevista a TV</a></span><span class="widget-news-item-date">22 abr 2018 - 19h04</span></div></li></ul></div>
<p>Contudo, o pré-candidato do DEM, Rodrigo Maia, que é presidente da Câmara dos Deputados, participa do evento em Niterói e abriu a série de apresentações do &#8220;Diálogo com Presidenciáveis&#8221;.</p>
<p>Além de Rodrigo Maia, confirmaram presença no evento Aldo Rebelo (SD), Álvaro Dias (Podemos), Ciro Gomes (PDT),  Geraldo Alckmin (PSDB), Guilherme Afif Domingos (PSD), Guilherme Boulos (PSOL), Henrique Meirelles (MDB), Manuela D&#8217;Ávila (PCdoB), Marina Silva (Rede) e Paulo Rabello (PSC).</p>
<p>Cada um terá cerca de 25 minutos para falar. Após as apresentações, os presidenciáveis concederão uma entrevista de cinco minutos para os jornalistas que fazem a cobertura. Não haverá debate.</p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/politica/bolsonaro-e-o-unico-ausente-em-evento-com-presidenciaveis-no-rj/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2018/02/brasil-jair-bolsonaro-20160914-002.jpg" length="48000000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2018/02/brasil-jair-bolsonaro-20160914-002.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2018/02/brasil-jair-bolsonaro-20160914-002.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Deputado Jair Bolsonaro</media:title>
		</media:content>

		<media:content url="http://1.gravatar.com/avatar/76fc2215beda2e1c0873dfe58e86efdf?s=96&#38;d=https%3A%2F%2F1.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">wpestadao</media:title>
		</media:content>
	</item>
		<item>
		<title>Cate Blanchett em Cannes: ‘Ser bonita não significa falta de inteligência’</title>
		<link>https://veja.abril.com.br/entretenimento/cate-blanchett-em-cannes-ser-bonita-nao-significa-falta-de-inteligencia/</link>
		<comments>https://veja.abril.com.br/entretenimento/cate-blanchett-em-cannes-ser-bonita-nao-significa-falta-de-inteligencia/#respond</comments>
		<pubDate>Tue, 08 May 2018 14:25:57 +0000</pubDate>
		<dc:creator><![CDATA[Raquel Carneiro]]></dc:creator>
				<category><![CDATA[Entretenimento]]></category>
		<category><![CDATA[Cannes]]></category>
		<category><![CDATA[Cate Blanchett]]></category>
		<category><![CDATA[Cinema]]></category>
		<category><![CDATA[Festival de Cannes]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525425</guid>
		<description><![CDATA[Atriz e presidente do júri do festival foi bombardeada por perguntas sobre feminismo e igualdade de gênero em coletiva de imprensa
]]></description>
				<content:encoded><![CDATA[<p>Presidente do júri deste ano, a atriz <span><strong>Cate Blanchett</strong> lidou de forma elegante com as muitas questões sobre igualdade de gênero feitas pela imprensa mundial durante coletiva no <strong>Festival de Cannes</strong>. O evento, que começa nesta terça-feira, 8, e vai até o dia 19, foi alvo de críticas por selecionar apenas três mulheres entre os 21 cineastas que competem pela <strong>Palma de Ouro</strong>. No passado, regra que continua valendo, o festival já foi criticado por proibir a passagem de mulheres sem salto alto pelo tapete vermelho, </span><span>um dos mais cobiçados do mundo.</span></p>
<p><span>Sobre o tapete ser uma espécie de “vitrine” para as mulheres, Cate defendeu: “Ser bonita não é sinônimo de falta de inteligência. Cannes é um festival glamouroso, que deve ser apreciado em todos os seus aspectos”. A resposta foi abraçada pelas outras mulheres do júri, Ava DuVernay, Khadja Nin, Léa Seydoux e Kristen Stewart. </span></p>
<figure><img src="https://abrilveja.files.wordpress.com/2018/05/cinema-coletiva-cannes-20180508-001.jpg" /><figcaption>Cate Blanchett, presidente do júri de Cannes em 2018, e os membros Chang Chen, Ava DuVernay, Robert Guediguian, Khadja Nin, Kristen Stewart, Denis Villeneuve e Andrey Zvyagintsev, durante coletiva de imprensa &#8211; 08/05/2048<span class="copyright">Reuters</span></figcaption></figure>
<p>&nbsp;</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/entretenimento">Entretenimento</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/entretenimento/festival-de-cannes-2018-sem-selfies-mas-com-polemicas/">Festival de Cannes 2018: Sem selfies, mas com polêmicas</a></span><span class="widget-news-item-date">8 maio 2018 - 09h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/entretenimento">Entretenimento</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/entretenimento/13-destaques-do-festival-de-cannes-2018-para-ficar-de-olho/">Treze destaques do Festival de Cannes 2018 para ficar de olho</a></span><span class="widget-news-item-date">8 maio 2018 - 10h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/entretenimento">Entretenimento</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/entretenimento/festival-de-cannes-esta-em-debito-com-cineastas-mulheres/">Festival de Cannes está em débito com cineastas mulheres</a></span><span class="widget-news-item-date">12 abr 2018 - 20h04</span></div></li></ul></div>
<p><span>Ao fato de mulheres serem minoria entre os competidores, a atriz também respondeu com sabedoria. “Esse número já foi menor em outras edições. As mudanças não acontecem do dia para a noite. Se quero ver mais mulheres competindo pela Palma de Ouro? Sim, claro. Mas hoje vamos trabalhar com o que temos e continuar pensando em mudanças para o futuro.” </span></p>
<p><span>Para finalizar, ela ressaltou, mais de uma vez, que a escolha do vencedor não será feita a partir de agendas políticas. “Este não é um festival político. Vamos assistir aos filmes sem pensar em nome de diretores, nacionalidade, questão de gênero. Queremos eleger um filme que seja atemporal e universal, e que ao mesmo tempo reflita o nosso hoje.”</span></p>
<p>&nbsp;</p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/entretenimento/cate-blanchett-em-cannes-ser-bonita-nao-significa-falta-de-inteligencia/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2018/05/cinema-cannes-cate-blanchett-20180508-001.jpg" length="48000000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2018/05/cinema-cannes-cate-blanchett-20180508-001.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2018/05/cinema-cannes-cate-blanchett-20180508-001.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Cate Blanchett</media:title>
		</media:content>

		<media:content url="http://1.gravatar.com/avatar/12a9524bee37f1eeadffe7d7975d22a2?s=96&#38;d=https%3A%2F%2F1.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">rachscarneiro</media:title>
		</media:content>

		<media:content url="http://abrilveja.files.wordpress.com/2018/05/cinema-coletiva-cannes-20180508-001.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">71º Festival de Cinema de Cannes</media:title>
		</media:content>
	</item>
		<item>
		<title>Nova Zelândia anuncia igualdade salarial para equipes masculina e feminina</title>
		<link>https://veja.abril.com.br/esporte/nova-zelandia-anuncia-igualdade-salarial-para-equipes-masculina-e-feminina/</link>
		<comments>https://veja.abril.com.br/esporte/nova-zelandia-anuncia-igualdade-salarial-para-equipes-masculina-e-feminina/#respond</comments>
		<pubDate>Tue, 08 May 2018 14:19:20 +0000</pubDate>
		<dc:creator><![CDATA[AFP]]></dc:creator>
				<category><![CDATA[Esporte]]></category>
		<category><![CDATA[Futebol Feminino]]></category>
		<category><![CDATA[Nova Zelândia]]></category>
		<category><![CDATA[Seleção de Futebol da Nova Zelândia]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525118</guid>
		<description><![CDATA[Premiações e pagamentos de direitos de imagem terão os mesmos valores e as jogadoras neozelandesas viajarão de primeira classe, como os homens]]></description>
				<content:encoded><![CDATA[<p>A <strong>Federação Neozelandesa de Futebol</strong> anunciou nesta terça-feira que decidiu estabelecer as mesmas condições salariais para jogadores e jogadoras da <strong><a href="https://veja.abril.com.br/noticias-sobre/selecao-de-futebol-da-nova-zelandia/">seleção nacional</a></strong>, o que chamou de um &#8220;momento chave&#8221; para o futebol do país.</p>
<p>A seleção masculina, conhecida como <em>All Whites</em>, e a<strong><a href="https://veja.abril.com.br/noticias-sobre/futebol-feminino/"> feminina</a></strong>, as <em>Football Ferns</em>, serão a partir de agora tratadas de maneira igualitária, afirmou o diretor geral da federação, Andy Martin.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/esporte">Esporte</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/esporte/opiniao-futebol-feminino-pede-respeito-mas-e-preciso-mais/">Opinião: futebol feminino pede respeito. Mas é preciso mais</a></span><span class="widget-news-item-date">4 maio 2018 - 15h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/esporte">Esporte</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/esporte/vozes-do-futebol-as-dificuldades-do-futebol-feminino-em-goiania/">Vozes do Futebol: as dificuldades do futebol feminino em Goiânia</a></span><span class="widget-news-item-date">2 maio 2018 - 12h05</span></div></li></ul></div>
<p>De modo concreto, as premiações e os direitos de imagem terão os mesmos valores e as jogadoras viajarão de primeira classe, como os homens. A Nova Zelândia segue o exemplo da Noruega, que estabeleceu as mesmas condições financeiras para as seleções masculina e feminina.</p>
<p>A Federação Neozelandesa de Rúgbi anunciou este ano que sua equipe feminina, cinco vezes campeã mundial, terá pela primeira vez contratos profissionais.</p>
<div class="embed-twitter">
<blockquote class="twitter-tweet" data-width="500" data-dnt="true">
<p lang="en" dir="ltr">NEWS | <a href="https://twitter.com/NZ_Football?ref_src=twsrc%5Etfw">@NZ_Football</a> is pleased to announce a ground-breaking agreement for equality and parity across its elite men&#39;s and women&#39;s national teams <a href="https://t.co/AZJ4WYiY96">https://t.co/AZJ4WYiY96</a> <a href="https://t.co/XpeBo9QQx3">pic.twitter.com/XpeBo9QQx3</a></p>
<p>&mdash; New Zealand Football (@NZ_Football) <a href="https://twitter.com/NZ_Football/status/993642418095308801?ref_src=twsrc%5Etfw">May 8, 2018</a></p></blockquote>
<p><script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script></div>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/esporte/nova-zelandia-anuncia-igualdade-salarial-para-equipes-masculina-e-feminina/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2018/05/selecao-feminina-nova-zelandia.jpg" length="48000000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2018/05/selecao-feminina-nova-zelandia.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2018/05/selecao-feminina-nova-zelandia.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Seleção de futebol feminino da Nova Zelândia</media:title>
		</media:content>

		<media:content url="http://2.gravatar.com/avatar/51caac186141e6c36ba6e7b8226625fd?s=96&#38;d=https%3A%2F%2F2.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">wpafp</media:title>
		</media:content>
	</item>
		<item>
		<title>Anitta critica final do novo &#8216;Vingadores&#8217; no Twitter &#8212; com spoilers</title>
		<link>https://veja.abril.com.br/entretenimento/anitta-critica-final-do-novo-vingadores-no-twitter-e-apaga-depois/</link>
		<comments>https://veja.abril.com.br/entretenimento/anitta-critica-final-do-novo-vingadores-no-twitter-e-apaga-depois/#respond</comments>
		<pubDate>Tue, 08 May 2018 14:17:23 +0000</pubDate>
		<dc:creator><![CDATA[Lucas Almeida]]></dc:creator>
				<category><![CDATA[Entretenimento]]></category>
		<category><![CDATA[Anitta]]></category>
		<category><![CDATA[Filme]]></category>
		<category><![CDATA[Marvel]]></category>
		<category><![CDATA[Twitter]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525369</guid>
		<description><![CDATA['Não pode não gostar. Amo tudo, amo todos', afirmou a cantora com ironia depois de receber críticas no Twitter]]></description>
				<content:encoded><![CDATA[<p><strong>Anitta</strong> demonstrou o seu descontentamento com o final do filme <strong><em>Vingadores: Guerra Infinita</em></strong> pelo <strong>Twitter</strong>, na noite desta segunda-feira. A cantora acabou revelando spoilers sobre o longa e recebeu críticas dos fãs. Pouco depois, apagou os comentários e afirmou, de modo ambíguo ou irônico: &#8220;N<span>ão pode não gostar. Amo tudo, amo todos&#8230; e paz na terra da liberdade&#8221;, escreveu com ironia. </span></p>
<p><em>(Atenção: o texto abaixo contém spoilers sobre o filme </em>Vingadores: Guerra Infinita<em>)</em></p>
<p>&#8220;Perda de tempo do dia: assistir a <em>Vingadores: Guerra Infinita</em>&#8220;, desabafou Anitta na rede social. &#8220;1. Morre todo mundo 2. Por motivos idiotas 3. Sensação de impotência do início ao fim 4. O inimigo merece vencer&#8230; e vence&#8221;, listou.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/entretenimento">Entretenimento</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/entretenimento/gisele-posta-video-dancando-coreografia-com-musica-de-anitta/">Gisele posta vídeo dançando coreografia com música de Anitta</a></span><span class="widget-news-item-date">27 abr 2018 - 10h04</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/entretenimento">Entretenimento</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/entretenimento/anitta-evita-rotulo-de-feminista-mas-defende-a-igualdade/">Anitta evita rótulo de feminista, mas defende &#8216;a igualdade&#8217;</a></span><span class="widget-news-item-date">26 abr 2018 - 12h04</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/entretenimento">Entretenimento</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/entretenimento/morre-alda-meneghel-mae-de-xuxa-aos-81-anos/">Morre Alda Meneghel, mãe de Xuxa, aos 81 anos</a></span><span class="widget-news-item-date">8 maio 2018 - 11h05</span></div></li></ul></div>
<p>O 19° filme do universo cinematográfico da <strong>Marvel</strong> reuniu diversos heróis dos quadrinhos da editora e chocou os fãs pelo número de mortes na história, <span>incluindo as de </span>Pantera Negra, Homem-Aranha e Doutor Estranho. O longa acompanha a luta dos personagens para combater <strong>Thanos</strong>, o vilão que busca <a href="https://veja.abril.com.br/entretenimento/joias-do-infinito-o-que-voce-precisa-saber-antes-do-novo-vingadores/" target="_blank" rel="noopener">reunir as seis joias do infinito</a>, que podem destruir o universo.</p>
<div class="embed-twitter">
<blockquote class="twitter-tweet" data-width="500" data-dnt="true">
<p lang="pt" dir="ltr">Apagando meu tweet sobre não ter gostado do filme por motivos de: não pode não gostar <img src="https://s0.wp.com/wp-content/mu-plugins/wpcom-smileys/twemoji/2/72x72/1f602.png" alt="😂" class="wp-smiley" /></p>
<p>&mdash; Anitta (@Anitta) <a href="https://twitter.com/Anitta/status/993645664864296961?ref_src=twsrc%5Etfw">May 8, 2018</a></p></blockquote>
<p><script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script></div>
<div class="embed-twitter">
<blockquote class="twitter-tweet" data-width="500" data-dnt="true">
<p lang="pt" dir="ltr">Amo tudo, amo todos &#8230;.. e paz na terra da liberdade</p>
<p>&mdash; Anitta (@Anitta) <a href="https://twitter.com/Anitta/status/993645864349560832?ref_src=twsrc%5Etfw">May 8, 2018</a></p></blockquote>
<p><script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script></div>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/entretenimento/anitta-critica-final-do-novo-vingadores-no-twitter-e-apaga-depois/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2018/02/entrete-anitta-lo-nuestro.jpg" length="3000000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2018/02/entrete-anitta-lo-nuestro.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2018/02/entrete-anitta-lo-nuestro.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Anitta</media:title>
		</media:content>

		<media:content url="http://0.gravatar.com/avatar/06cd20701ff9a012e00e2f3e9f0b5267?s=96&#38;d=https%3A%2F%2F0.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">almeidalucas1206</media:title>
		</media:content>
	</item>
		<item>
		<title>Bill Cosby perde prêmios após condenação por agressão sexual</title>
		<link>https://veja.abril.com.br/entretenimento/bill-cosby-perde-premios-apos-condenacao-por-agressao-sexual/</link>
		<comments>https://veja.abril.com.br/entretenimento/bill-cosby-perde-premios-apos-condenacao-por-agressao-sexual/#respond</comments>
		<pubDate>Tue, 08 May 2018 14:16:58 +0000</pubDate>
		<dc:creator><![CDATA[EFE]]></dc:creator>
				<category><![CDATA[Entretenimento]]></category>
		<category><![CDATA[Abuso Sexual]]></category>
		<category><![CDATA[Assédio Sexual]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525032</guid>
		<description><![CDATA[Centro Kennedy de Washington dele as honrarias Kennedy e Mark Twain, duas das mais prestigiados no setor cultural dos Estados Unidos]]></description>
				<content:encoded><![CDATA[<p>O Centro Kennedy de Washington retirou nesta segunda-feira do comediante <strong>Bill Cosby</strong>, recentemente condenado por <strong>agressão sexual</strong>, os prêmios Kennedy e Mark Twain, dois dos mais prestigiados no setor cultural dos Estados Unidos. &#8220;Como resultado da sua recente condenação, o conselho concluiu que os atos de Cosby ofuscaram as conquistas profissionais que estas distinções procuram reconhecer&#8221;, afirmou o órgão cultural em comunicado.</p>
<p>Cosby recebeu em 1998 o Prêmio Kennedy, que reconhece sua contribuição para a cultura americana. Já em 2009, recebeu o Prêmio Mark Twain, dedicado à comédia dos Estados Unidos. Trata-se de dois dos mais prestigiados prêmios concedidos na esfera cultural americana, cuja entrega costuma ter o comparecimento do presidente do país, embora o atual líder, Donald Trump, tenha quebrado esta tradição no ano passado.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/entretenimento">Entretenimento</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/entretenimento/academia-de-hollywood-expulsa-bill-cosby-e-roman-polanski/">Academia de Hollywood expulsa Bill Cosby e Roman Polanski</a></span><span class="widget-news-item-date">3 maio 2018 - 16h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/entretenimento">Entretenimento</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/entretenimento/esposa-defende-bill-cosby-contra-linchamento-publico/">Esposa defende Bill Cosby contra &#8216;linchamento&#8217; público</a></span><span class="widget-news-item-date">3 maio 2018 - 13h05</span></div></li></ul></div>
<p>O Centro John F. Kennedy de Artes Cênicas, em Washington, é uma iniciativa público-privada inaugurada em 1971 como o memorial do país ao presidente John Kennedy, assassinado em 1963.</p>
<p>&nbsp;</p>
<h3>Histórico judicial</h3>
<p>Cosby, ícone da cultura popular dos EUA, foi considerado culpado no dia 26 de abril por três crimes de agressão sexual em um julgamento carregado de simbolismo, por ser o primeiro de uma personalidade famosa desde a eclosão do movimento &#8220;Me too&#8221;.</p>
<p>Mais de 60 mulheres acusaram Bill Cosby de abusar sexualmente delas entre os anos 1960 e 2000. A maioria dos casos não prosperou pois havia prescrito, e o comediante só prestou contas pelas acusações da canadense Andrea Constand. Os crimes pelos quais foi declarado culpado o ator são penetração sem consentimento, penetração enquanto a vítima está inconsciente e penetração após o fornecimento de entorpecente.</p>
<p>Após conhecer sua pena, a Academia de Artes e Ciências Cinematográficas de Hollywood expulsou Cosby por não cumprir as normas de conduta da organização, juntamente com .</p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/entretenimento/bill-cosby-perde-premios-apos-condenacao-por-agressao-sexual/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2017/06/bill-cosby-tribunal.jpg" length="6750000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2017/06/bill-cosby-tribunal.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2017/06/bill-cosby-tribunal.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Julgamento de Bill Cosby</media:title>
		</media:content>

		<media:content url="http://1.gravatar.com/avatar/7c89f05f74936e5a0a05a29d0f9c7556?s=96&#38;d=https%3A%2F%2F1.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">wpagenciaefe</media:title>
		</media:content>
	</item>
		<item>
		<title>&#8216;É preciso respeitar a vocação das pessoas&#8217;, diz França sobre Barbosa</title>
		<link>https://veja.abril.com.br/politica/e-preciso-respeitar-a-vocacao-das-pessoas-diz-franca-sobre-barbosa/</link>
		<comments>https://veja.abril.com.br/politica/e-preciso-respeitar-a-vocacao-das-pessoas-diz-franca-sobre-barbosa/#respond</comments>
		<pubDate>Tue, 08 May 2018 14:09:12 +0000</pubDate>
		<dc:creator><![CDATA[Guilherme Venaglia]]></dc:creator>
				<category><![CDATA[Política]]></category>
		<category><![CDATA[Eleições 2018]]></category>
		<category><![CDATA[Geraldo Alckmin]]></category>
		<category><![CDATA[Jair Bolsonaro]]></category>
		<category><![CDATA[Joaquim Barbosa]]></category>
		<category><![CDATA[Márcio França]]></category>
		<category><![CDATA[PSB]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525376</guid>
		<description><![CDATA[Segundo governador, sondagens feitas pelo partido indicavam que ele começava a ultrapassar Bolsonaro; tendência do PSB, agora, é a de não ter candidato]]></description>
				<content:encoded><![CDATA[<p>O governador de São Paulo, <a href="https://veja.abril.com.br/noticias-sobre/marcio-franca"><strong>Márcio França</strong></a> (PSB), considerou a decisão de &#8220;um homem sábio&#8221; o anúncio de <a href="https://veja.abril.com.br/noticias-sobre/joaquim-barbosa"><strong>Joaquim Barbosa</strong></a>, filiado ao <a href="https://veja.abril.com.br/noticias-sobre/psb"><strong>PSB</strong></a>, de que ele não será candidato à Presidência da República.</p>
<p>&#8220;Ele já vinha dando sinais, não sentia nele a disposição de viver a atividade política nas vezes em que estivemos juntos. É preciso respeitar a vocação das pessoas e o tempo de cada um. Ele foi um homem sábio de entender que não era o momento, é necessária uma vivência eleitoral e política antes de almejar um cargo como a Presidência da República&#8221;, afirmou a VEJA.</p>
<p>De acordo com o governador, sondagens internas feitas pelo partido indicavam que ele começava a superar o deputado <a href="https://veja.abril.com.br/noticias-sobre/jair-bolsonaro"><strong>Jair Bolsonaro</strong></a> (PSL), líder nos cenários sem o ex-presidente Luiz Inácio Lula da Silva (PT), na preferência dos eleitores. Na última pesquisa do instituto Datafolha, o ex-presidente do STF aparecia com cerca de 10% das intenções de voto nos cenários sem Lula, atrás apenas de Bolsonaro e da ex-senadora Marina Silva (Rede).</p>
<p>Na visão de Márcio França, com a desistência de Joaquim, os socialistas ficam &#8220;sem uma candidatura óbvia&#8221; e vão ter que reiniciar as conversas sobre o futuro da legenda nas eleições de 2018.</p>
<p>&#8220;A candidatura do ministro Joaquim, um nome forte e respeitado, era honrosa para o PSB. Agora, acredito que a tendência é não ter candidato, o que é sempre mais fácil, mas ainda vamos discutir esse assunto&#8221;, afirmou. Internamente, Márcio França e os diretórios do PSB em São Paulo, Santa Catarina e Paraná defendem que a legenda apoie a pré-candidatura do ex-governador <a href="https://veja.abril.com.br/noticias-sobre/geraldo-alckmin"><strong>Geraldo Alckmin</strong></a> (PSDB), de quem ele herdou o comando do Palácio dos Bandeirantes.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/politica">Política</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/blog/radar/joaquim-barbosa-desiste-de-candidatura-a-presidencia/">Joaquim Barbosa desiste de candidatura à Presidência</a></span><span class="widget-news-item-date">8 maio 2018 - 10h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/politica">Política</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/politica/psb-cobra-mais-entrosamento-de-joaquim-barbosa-com-partido/">PSB cobra mais &#8216;entrosamento&#8217; de Joaquim Barbosa com partido</a></span><span class="widget-news-item-date">12 abr 2018 - 09h04</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/politica">Política</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/politica/pre-candidatos-a-presidencia-comentam-pesquisa-datafolha/">Pré-candidatos à Presidência comentam pesquisa Datafolha</a></span><span class="widget-news-item-date">15 abr 2018 - 18h04</span></div></li></ul></div>
<p>Por outro lado, os diretórios socialistas na região nordeste, sobretudo em Pernambuco, resistem e flertam com alternativas mais à esquerda, como uma composição com o PT ou com o ex-ministro Ciro Gomes (PDT).</p>
<p>A expectativa é a de que o PSB possa mesmo acabar neutro para evitar acentuar as divergências no partido. &#8220;Eu farei sempre essa defesa [da aliança com Alckmin], mas são 600 delegados e ir para o voto é sempre mais difícil, porque o partido acaba ficando dividido de alguma forma&#8221;, comentou.</p>
<p>Desde 2014, quando o principal líder socialista, o ex-governador de Pernambuco e então candidato à Presidência Eduardo Campos, faleceu em um acidente aéreo, o partido encontra dificuldades para atuar de forma unida.</p>
<p>Durante a última janela partidária, parlamentares que destoavam do posicionamento mais à esquerda adotado no último ano acabaram migrando para outros partidos. Então líder na Câmara, a deputada Tereza Cristina (MS), por exemplo, se filiou ao DEM.</p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/politica/e-preciso-respeitar-a-vocacao-das-pessoas-diz-franca-sobre-barbosa/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2018/05/brasil-marcio-franca-20180426-001.jpg" length="48000000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2018/05/brasil-marcio-franca-20180426-001.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2018/05/brasil-marcio-franca-20180426-001.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Márcio França</media:title>
		</media:content>

		<media:content url="http://2.gravatar.com/avatar/e83fffe1cdf177230918914039b3cb36?s=96&#38;d=https%3A%2F%2F2.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">gvenaglia</media:title>
		</media:content>
	</item>
		<item>
		<title>Palmeiras zera dívida com Paulo Nobre 7 anos antes do prazo</title>
		<link>https://veja.abril.com.br/esporte/palmeiras-zera-divida-com-paulo-nobre-7-anos-antes-do-prazo/</link>
		<comments>https://veja.abril.com.br/esporte/palmeiras-zera-divida-com-paulo-nobre-7-anos-antes-do-prazo/#respond</comments>
		<pubDate>Tue, 08 May 2018 13:36:50 +0000</pubDate>
		<dc:creator><![CDATA[Gazeta Press]]></dc:creator>
				<category><![CDATA[Esporte]]></category>
		<category><![CDATA[Placar]]></category>
		<category><![CDATA[Marketing Esportivo]]></category>
		<category><![CDATA[Palmeiras]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2524987</guid>
		<description><![CDATA[Ex-presidente emprestou quase R$ 200 milhões ao clube]]></description>
				<content:encoded><![CDATA[<p>O <a href="https://veja.abril.com.br/noticias-sobre/palmeiras/"><strong>Palmeiras</strong></a> já não deve mais nada a seu ex-presidente <strong>Paulo Nobre</strong>. Na última semana, a diretoria alviverde quitou o último pagamento devido ao ex-dirigente, que emprestou quase<strong> 200 milhões de reais</strong> ao clube (considerando ativos repassados em direitos de atletas) durante seus dois mandatos.</p>
<p>O pagamento a Paulo Nobre foi realizado muito antes do que era esperado pelo próprio ex-mandatário, que previa um acerto em até dez anos. Em três, porém, a dívida foi paga (considerando que o ex-presidente ainda tem valores a receber pelos direitos econômicos de Tobio, Allione, Mouche e Róger Guedes, jogadores que ajudou a contratar).</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/esporte">Esporte</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/placar/valdivia-marca-golaco-no-chile-e-celebra-magia-esta-intacta/">Valdivia marca golaço no Chile e celebra: &#8216;Magia está intacta&#8217;</a></span><span class="widget-news-item-date">7 maio 2018 - 10h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/placar">Placar</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/placar/palmeiras-confirma-classico-contra-o-sao-paulo-no-allianz-parque/">Palmeiras confirma clássico contra o São Paulo no Allianz Parque</a></span><span class="widget-news-item-date">7 maio 2018 - 16h05</span></div></li></ul></div>
<p>O primeiro fundo para pagamento de Nobre foi aprovado ainda em 2014 e previa a quitação de 104 milhões de reais em dez anos por meio de depósitos de 10% da renda bruta mensal do clube. O repasse da quantia começou em maio de 2015, terminou na última sexta-feira, e foi entregue corrigido com juros (de valor inferior ao praticado no mercado).</p>
<p>Antes deste fundo, outro já havia sido quitado em 2017, no valor de 41 milhões de reais. Para esta quantia, o Palmeiras utilizou luvas recebidas do Esporte Interativo em contrato assinado para transmissão de partidas em TV fechada.</p>
<p>Desde que assumiu a presidência do Palmeiras, no final de 2016, Maurício Galiotte colocou como meta zerar todas as dívidas do clube. Apesar de quitar os débitos com Paulo Nobre, porém, uma mudança nos acertos dos jogadores contratados pela Crefisa criou uma dívida de 120 milhões de reais com a patrocinadora. O caso está sendo tratado pelo Conselho de Orientação e Fiscalização (COF).</p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/esporte/palmeiras-zera-divida-com-paulo-nobre-7-anos-antes-do-prazo/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2016/09/esporte-palmeiras-paulo-nobre.jpg" length="12000000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2016/09/esporte-palmeiras-paulo-nobre.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2016/09/esporte-palmeiras-paulo-nobre.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">O presidente do Palmeiras, Paulo Nobre</media:title>
		</media:content>

		<media:content url="http://1.gravatar.com/avatar/df350ed6ef0b33f23b5643a2e8b419b7?s=96&#38;d=https%3A%2F%2F1.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">wpgazetapress</media:title>
		</media:content>
	</item>
		<item>
		<title>Kim Jong-un reúne-se a Xi Jinping pela segunda vez na China</title>
		<link>https://veja.abril.com.br/mundo/kim-jong-un-reune-se-a-xi-jinping-pela-segunda-vez-na-china/</link>
		<comments>https://veja.abril.com.br/mundo/kim-jong-un-reune-se-a-xi-jinping-pela-segunda-vez-na-china/#comments</comments>
		<pubDate>Tue, 08 May 2018 13:36:03 +0000</pubDate>
		<dc:creator><![CDATA[Carolina Marins]]></dc:creator>
				<category><![CDATA[Mundo]]></category>
		<category><![CDATA[China]]></category>
		<category><![CDATA[Coreia do Norte]]></category>
		<category><![CDATA[Kim Jong-un]]></category>
		<category><![CDATA[XI Jinping]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525273</guid>
		<description><![CDATA[Imprensa chinesa confirmou nesta terça-feira que os líderes se reuniram para avaliar as negociações de paz entre as duas Coreias]]></description>
				<content:encoded><![CDATA[<p>O presidente da <a href="https://veja.abril.com.br/noticias-sobre/china/"><strong>China</strong></a>, <a href="https://veja.abril.com.br/noticias-sobre/xi-jinping/"><strong>Xi Jinping</strong></a>, e o líder norte-coreano, <a href="https://veja.abril.com.br/noticias-sobre/kim-jong-un/"><strong>Kim Jong-un</strong></a>, se reuniram nestas segunda (7) e terça-feira (8) na cidade chinesa de <strong>Dalian</strong> para avaliar os progressos diplomáticos conquistados na península coreana nos últimos meses e as perspectivas para o futuro, anunciou a imprensa oficial chinesa.</p>
<p>A <strong><a href="https://veja.abril.com.br/mundo/kim-jong-un-tem-encontro-historico-com-presidente-sul-coreano/">reunião acontece menos de duas semanas depois da histórica cúpula intercoreana</a>,</strong>realizada em 27 de abril, na qual foi dado o primeiro passo para a reconciliação entre as duas Coreias. Há expectativas, agora, sobre a reunião entre Kim Jong-un e <a href="https://veja.abril.com.br/noticias-sobre/donald-trump/"><strong>Donald Trump</strong></a>, <strong><a href="https://veja.abril.com.br/mundo/trump-diz-que-pode-se-reunir-com-kim-jong-un-em-um-mes/">prevista entre o fim deste mês e o início do próximo</a></strong>.</p>
<p>Xi afirmou a Kim que está &#8220;feliz&#8221; com o &#8220;progresso positivo&#8221; da situação na península coreana desde a primeira reunião entre ambos, no final de março em Pequim, segundo indicou a agência oficial chinesa <em>Xinhua</em>. Mas há sinais sobre sua insatisfação com o alijamento da China e a maior influência dos Estados Unidos nas negociações de paz entre as Coreias. Xi quer ainda evitar que Pyongyang saia da esfera de poder chinesa.</p>
<p>Por sua vez, o líder norte-coreano destacou ao presidente da China que a situação na península &#8220;experimentou avanços significativos&#8221;. &#8220;Estes são os resultados positivos da reunião histórica&#8221; de março em <a href="https://veja.abril.com.br/noticias-sobre/pequim/"><strong>Pequim</strong></a>, afirmou Kim Jong-un.</p>
<p>A reunião em Dalian seguiu o tradicional sigilo dos encontros entre dirigentes de ambos países. Somente foi confirmada depois de seu término.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/mundo">Mundo</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/mundo/coreia-do-norte-muda-fuso-horario-para-ajusta-lo-ao-do-sul/">Coreia do Norte muda fuso horário para ajustá-lo ao do Sul</a></span><span class="widget-news-item-date">4 maio 2018 - 21h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/mundo">Mundo</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/mundo/apos-11-anos-chanceler-chines-se-reune-com-lider-da-coreia-do-norte/">Após 11 anos, chanceler chinês se reúne com líder da Coreia do Norte</a></span><span class="widget-news-item-date">3 maio 2018 - 11h05</span></div></li></ul></div>
<p>Só alguns veículos de imprensa asiáticos disseram nesta terça-feira que havia um avião norte-coreano em Dalian, enquanto o jornal de Hong Kong <i>The South China Morning Post</i> avançou que Xi, cuja viagem para essa cidade era esperada para os  testes do primeiro porta-aviões construído pela China, poderia ter se reunido com o próprio Kim Jong-un.</p>
<p>Na semana passada, o ministro chinês das Relações Exteriores, <strong>Wang Yi</strong>, <strong><a href="https://veja.abril.com.br/mundo/chanceler-chines-visita-coreia-do-norte-nesta-semana/">viajou para Pyongyang e se reuniu com Kim</a></strong>, que insistiu na determinação de eliminar as armas nucleares da península coreana.</p>
<p>A China é o principal aliado da <a href="https://veja.abril.com.br/noticias-sobre/coreia-do-norte/"><strong>Coreia do Norte</strong></a>, embora o comércio bilateral tenha despencado nos últimos meses à medida que Pequim aplicou sanções econômicas aprovadas pela <a href="https://veja.abril.com.br/noticias-sobre/onu/"><strong>ONU</strong></a>, em resposta às atividades nucleares e testes com mísseis da Coreia do Norte.</p>
<p>Nesta terça-feira, o presidente dos <a href="https://veja.abril.com.br/noticias-sobre/estados-unidos/"><strong>Estados Unidos</strong> </a>publicou no Twitter que falará por telefone com Xi Jinping para discutir a situação com a Coreia do Norte, as relações bilaterais e comerciais entre Pequim e Washington.</p>
<div class="embed-twitter">
<blockquote class="twitter-tweet" data-width="500" data-dnt="true">
<p lang="en" dir="ltr">I will be speaking to my friend, President Xi of China, this morning at 8:30. The primary topics will be Trade, where good things will happen, and North Korea, where relationships and trust are building.</p>
<p>&mdash; Donald J. Trump (@realDonaldTrump) <a href="https://twitter.com/realDonaldTrump/status/993813485745295360?ref_src=twsrc%5Etfw">May 8, 2018</a></p></blockquote>
<p><script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script></div>
<p><em>(Com EFE e Estadão Conteúdo)</em></p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/mundo/kim-jong-un-reune-se-a-xi-jinping-pela-segunda-vez-na-china/feed/</wfw:commentRss>
		<slash:comments>1</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2018/03/mundo-kim-jong-un-xi-jinping-20180328-001-copy.jpg" length="3000000" type="image/jpeg" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2018/03/mundo-kim-jong-un-xi-jinping-20180328-001-copy.jpg?quality=70&#038;strip=info" />
		<media:content url="http://abrilveja.files.wordpress.com/2018/03/mundo-kim-jong-un-xi-jinping-20180328-001-copy.jpg?quality=70&#038;strip=info" medium="image">
			<media:title type="html">Kim Jong Un cumprimenta presidente da China, Xi Jinping</media:title>
		</media:content>

		<media:content url="http://0.gravatar.com/avatar/348d358af5b8d6bb75e4a5af9fe789ae?s=96&#38;d=https%3A%2F%2F0.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">a67893</media:title>
		</media:content>
	</item>
		<item>
		<title>Alisson Mack é casada com atriz Nicki Clyne, de &#8216;Battlestar Galactica&#8217;</title>
		<link>https://veja.abril.com.br/entretenimento/alisson-mack-e-casada-com-atriz-nicki-clyne-de-battlestar-galactica/</link>
		<comments>https://veja.abril.com.br/entretenimento/alisson-mack-e-casada-com-atriz-nicki-clyne-de-battlestar-galactica/#respond</comments>
		<pubDate>Tue, 08 May 2018 13:29:04 +0000</pubDate>
		<dc:creator><![CDATA[Lucas Almeida]]></dc:creator>
				<category><![CDATA[Entretenimento]]></category>
		<category><![CDATA[Abuso Sexual]]></category>
		<category><![CDATA[Allison Mack]]></category>
		<category><![CDATA[Keith Raniere]]></category>
		<category><![CDATA[NXIVM]]></category>

		<guid isPermaLink="false">http://veja.abril.com.br/?p=2525260</guid>
		<description><![CDATA[Procuradores afirmaram a relação do casal durante sessão no tribunal para o julgamento de Mack, acusada de  tráfico sexual]]></description>
				<content:encoded><![CDATA[<p><strong>Allison Mack</strong>, que está sendo acusada de tráfico sexual dentro de uma seita, é casada com a atriz canadense <strong>Nicki</strong><strong> Clyne</strong>, que interpretava a <span>Cally na série </span><em><b>Battlestar</b><b> Galactica</b></em>. De acordo com o site americano <a href="https://www.eonline.com/news/932909/allison-mack-married-actress-nicki-clyne-prior-to-sex-trafficking-arrest">E! Online</a>, os procuradores federais tornaram público o relacionamento entre as duas durante uma das sessões do julgamento de Allison.</p>
<p>Documentos acessados pelo site americano mostram que <strong>Allison e Nicki </strong>se casaram em fevereiro de 2017 e vivem juntas em Nova York. As duas atrizes possuem fotos lado a lado nas redes sociais.</p>
<div class="widget-news widget-box no-margin no-border"><span class="widget-news-title content-box-title">Veja também</span><ul class="widget-news-list"><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/entretenimento">Entretenimento</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/entretenimento/seita-do-sexo-nxivm-allison-mack-depoe-em-tribunal/">Seita do sexo NXIVM: Allison Mack depõe em tribunal</a></span><span class="widget-news-item-date">6 maio 2018 - 12h05</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/entretenimento">Entretenimento</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/entretenimento/seita-de-allison-mack-financiava-atividades-com-cursos-de-us-5-000/">Seita sexual de Allison Mack financiava atividades com cursos de US$ 5.000</a></span><span class="widget-news-item-date">30 abr 2018 - 13h04</span></div></li><li class="widget-news-item without-thumb with-border"><div class="widget-news-info"><a href="/entretenimento">Entretenimento</a><span class="widget-news-item-title"><a href="https://veja.abril.com.br/entretenimento/quem-e-keith-raniere-criador-da-seita-do-sexo-de-allison-mack/">Quem é Keith Raniere, criador da seita do sexo de Allison Mack</a></span><span class="widget-news-item-date">26 abr 2018 - 16h04</span></div></li></ul></div>
<p>Allison Mack, que ficou conhecida pelo papel da ética jornalista <span>Chloe Sullivan na série <strong><em>Smallville</em></strong>, foi presa no fim de abril sob acusação de tráfico sexual e trabalhos forçados dentro da seita <strong>NXIVM</strong> (pronuncia-se <em>nexium</em>), liderada pelo guru da autoajuda Keith Raniere. A atriz foi solta após o pagamento de uma fiança de 5 milhões de dólares e está em prisão domiciliar na casa dos pais, na Califórnia.</span></p>
<p><span>Para a revista americana <a href="http://people.com/crime/smallvilles-allison-mack-married-battlestar-galacticas-nicki-clyne-in-2017-prosecutors/" target="_blank" rel="noopener"><em>People</em></a>, o jornalista Frank Parlato, que trabalhou para a seita entre 2007 e 2008, afirmou que</span> Nicki Clyne integra a <span><strong>NXIVM</strong> há doze anos<strong>.</strong></span></p>
]]></content:encoded>
			<wfw:commentRss>https://veja.abril.com.br/entretenimento/alisson-mack-e-casada-com-atriz-nicki-clyne-de-battlestar-galactica/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		<enclosure url="http://abrilveja.files.wordpress.com/2018/05/sem-tc3adtulo-1.png" length="3000000" type="image/png" />
	<source url="https://veja.abril.com.br">VEJA.com</source>

		<media:thumbnail url="https://abrilveja.files.wordpress.com/2018/05/sem-tc3adtulo-1.png" />
		<media:content url="http://abrilveja.files.wordpress.com/2018/05/sem-tc3adtulo-1.png" medium="image">
			<media:title type="html">Sem-título-1</media:title>
		</media:content>

		<media:content url="http://0.gravatar.com/avatar/06cd20701ff9a012e00e2f3e9f0b5267?s=96&#38;d=https%3A%2F%2F0.gravatar.com%2Favatar%2Fad516503a11cd5ca435acc9bb6523536%3Fs%3D96&#38;r=G" medium="image">
			<media:title type="html">almeidalucas1206</media:title>
		</media:content>
	</item>
	</channel>
</rss>
";}')); /* Child Type: integer */ $data['createdOn'] = 1525796552;