0byt3m1n1
Path:
/
home
/
mgatv524
/
public_html
/
sommatv
/
web
/
media
/
cache
/
0fea6a13c52b4d47
/
25368f24b045ca84
/
b8ac4316b44f99ee
/
f0cf6447439815bc
/
9d2b1ad5bbc16c44
/
d49116dc213c53f2
/
8a084cf70d891601
/
51bfe9722cb4c124
/
19c106a2552edf54
/
[
Home
]
File: dcf4be7875886eaa.php
<?php /* Cachekey: cache/xibo/widget/ticker/4a5d3116bd7d6503895e94ce527d198f/ */ /* Type: array */ /* Expiration: 2018-05-07T09:39:45-05:00 */ $loaded = true; $expiration = 1525703985; $data = array(); /* Child Type: array */ $data['return'] = unserialize(base64_decode('a:2:{s:8:"encoding";s:5:"UTF-8";s:3:"xml";s:60852:"<?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/"
	>

<channel>
	<title>Acontecendo Online</title>
	<atom:link href="http://www.acontecendoonline.com.br/feed/" rel="self" type="application/rss+xml" />
	<link>https://www.acontecendoonline.com.br</link>
	<description>Informação de qualidade ao seu alcance</description>
	<lastBuildDate>Mon, 07 May 2018 12:03:21 +0000</lastBuildDate>
	<language>pt-BR</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>https://wordpress.org/?v=4.7.10</generator>
	<item>
		<title>Michel Temer libera mais de R$ 4 bilhões para estados e municípios</title>
		<link>https://www.acontecendoonline.com.br/michel-temer-libera-mais-de-r-4-bilhoes-para-estados-e-municipios/</link>
		<comments>https://www.acontecendoonline.com.br/michel-temer-libera-mais-de-r-4-bilhoes-para-estados-e-municipios/#respond</comments>
		<pubDate>Mon, 07 May 2018 12:03:21 +0000</pubDate>
		<dc:creator><![CDATA[AGÊNCIA ANVA]]></dc:creator>
				<category><![CDATA[Nacionais]]></category>
		<category><![CDATA[Política]]></category>

		<guid isPermaLink="false">https://www.acontecendoonline.com.br/?p=13937</guid>
		<description><![CDATA[<img width="800" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/temer-vozdobrasil.jpeg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/temer-vozdobrasil.jpeg 800w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/temer-vozdobrasil-300x197.jpeg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/temer-vozdobrasil-768x504.jpeg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/temer-vozdobrasil-696x457.jpeg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/temer-vozdobrasil-741x486.jpeg 741w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/temer-vozdobrasil-640x420.jpeg 640w" sizes="(max-width: 800px) 100vw, 800px" />O presidente Michel Temer anunciou, neste domingo (6), por meio de sua conta oficial no Twitter, que assinou a liberação de crédito suplementar no valor de R$ 4 bilhões para estados e municípios. Os recursos são resultado das compensações financeiras pela produção de petróleo e gás natural. &#8220;Estes recursos irão beneficiar a população brasileira&#8221;, destacou [&#8230;]]]></description>
				<content:encoded><![CDATA[<img width="800" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/temer-vozdobrasil.jpeg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/temer-vozdobrasil.jpeg 800w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/temer-vozdobrasil-300x197.jpeg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/temer-vozdobrasil-768x504.jpeg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/temer-vozdobrasil-696x457.jpeg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/temer-vozdobrasil-741x486.jpeg 741w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/temer-vozdobrasil-640x420.jpeg 640w" sizes="(max-width: 800px) 100vw, 800px" /><p>O presidente Michel Temer anunciou, neste domingo (6), por meio de sua conta oficial no Twitter, que assinou a liberação de crédito suplementar no valor de R$ 4 bilhões para estados e municípios. Os recursos são resultado das compensações financeiras pela produção de petróleo e gás natural. &#8220;Estes recursos irão beneficiar a população brasileira&#8221;, destacou Temer, em seu comunicado.</p>
<p>O crédito suplementar havia sido aprovado no último dia 25, pelo Congresso Nacional, e prevê, além da compensação financeira decorrente da exploração de petróleo e gás, no valor de R$ 4,3 bilhões, a compensação pela utilização de recursos hídricos na geração de energia elétrica, no valor de R$ 6,7 milhões, e devolução de R$ 18,3 bilhões de Imposto Territorial Rural.</p>
<p>Os recursos a serem repassados são oriundos de excesso de arrecadação de impostos pela União. Na justificativa do projeto de lei, o governo havia assegurado que as transferências não afetam o alcance da meta fiscal prevista para este ano, que projeta um déficit primário de R$ 159 bilhões.<img class="wp-image-13727 aligncenter" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/b406c50f-b5dc-47bb-823c-77be6d35bb15-3-300x165.jpg" alt="" width="684" height="376" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/b406c50f-b5dc-47bb-823c-77be6d35bb15-3-300x165.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/b406c50f-b5dc-47bb-823c-77be6d35bb15-3-768x423.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/b406c50f-b5dc-47bb-823c-77be6d35bb15-3-1024x564.jpg 1024w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/b406c50f-b5dc-47bb-823c-77be6d35bb15-3-696x383.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/b406c50f-b5dc-47bb-823c-77be6d35bb15-3-1068x588.jpg 1068w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/b406c50f-b5dc-47bb-823c-77be6d35bb15-3-762x420.jpg 762w" sizes="(max-width: 684px) 100vw, 684px" /></p>
<p><img class="wp-image-13923 aligncenter" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11-300x247.jpg" alt="" width="701" height="577" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11-300x247.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11-768x632.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11-1024x843.jpg 1024w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11-696x573.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11-1068x879.jpg 1068w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11-510x420.jpg 510w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11.jpg 1306w" sizes="(max-width: 701px) 100vw, 701px" /></p>
]]></content:encoded>
			<wfw:commentRss>https://www.acontecendoonline.com.br/michel-temer-libera-mais-de-r-4-bilhoes-para-estados-e-municipios/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Acidente grave deixa duas vítimas fatais na BR-474 em Aimorés-MG.</title>
		<link>https://www.acontecendoonline.com.br/acidente-grave-deixa-duas-vitimas-fatais-na-br-474-em-aimores-mg/</link>
		<comments>https://www.acontecendoonline.com.br/acidente-grave-deixa-duas-vitimas-fatais-na-br-474-em-aimores-mg/#respond</comments>
		<pubDate>Sun, 06 May 2018 23:53:58 +0000</pubDate>
		<dc:creator><![CDATA[AGÊNCIA ANVA]]></dc:creator>
				<category><![CDATA[Polícia]]></category>

		<guid isPermaLink="false">https://www.acontecendoonline.com.br/?p=13930</guid>
		<description><![CDATA[<img width="799" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/IMG_20180506_185945097.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/IMG_20180506_185945097.jpg 799w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/IMG_20180506_185945097-300x197.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/IMG_20180506_185945097-768x505.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/IMG_20180506_185945097-696x457.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/IMG_20180506_185945097-741x486.jpg 741w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/IMG_20180506_185945097-639x420.jpg 639w" sizes="(max-width: 799px) 100vw, 799px" />Aimorés-MG –  Um acidente grave envolvendo dois veículos e duas motocicletas na noite desde domingo (06), deixou duas vítimas fatais e outras duas vítimas em estado grave. Segundo informações iniciais de testemunhas, duas motocicletas com dois ocupantes em cada motocicleta, seguiam sentido Aimorés após sair de uma festa em um local conhecido como Motocross, quando próximo [&#8230;]]]></description>
				<content:encoded><![CDATA[<img width="799" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/IMG_20180506_185945097.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/IMG_20180506_185945097.jpg 799w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/IMG_20180506_185945097-300x197.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/IMG_20180506_185945097-768x505.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/IMG_20180506_185945097-696x457.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/IMG_20180506_185945097-741x486.jpg 741w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/IMG_20180506_185945097-639x420.jpg 639w" sizes="(max-width: 799px) 100vw, 799px" /><p><strong>Aimorés-MG –  </strong>Um acidente grave envolvendo dois veículos e duas motocicletas na noite desde domingo (06), deixou duas vítimas fatais e outras duas vítimas em estado grave.</p>
<p>Segundo informações iniciais de testemunhas, duas motocicletas com dois ocupantes em cada motocicleta, seguiam sentido Aimorés após sair de uma festa em um local conhecido como Motocross, quando próximo a entrada para o antigo Pontilhão, colidiram com dois veículos que seguiam na direção contrária.</p>
<p>Um casal que estava em uma das motocicletas, não resistiu aos ferimentos e morreu no local, as outras duas vítimas que estavam na outra motocicleta foram socorridos e encaminhados ao pronto socorro de Aimorés e segundo informações, em estado grave.</p>
<p><strong>Vítimas identificadas</strong></p>
<p>O motorista de um dos veículos e o passageiro que o acompanhava, foram encaminhados ao hospital com escoriações e em estado de choque. Uma das vítimas fatais foi identificada como sendo Nilton Rodrigues, de 37 anos. A outra vítima que estava com ele na motocicleta, foi identificada como Marly Santos, de 36 anos. Nilton era bastante conhecido na cidade e trabalhava como pedreiro e tinha como especialidade a instalação de telhados.</p>
<p><img class="wp-image-13787 aligncenter" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/2-vertical-1-300x203.jpg" alt="" width="641" height="434" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/2-vertical-1-300x203.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/2-vertical-1-768x520.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/2-vertical-1-1024x693.jpg 1024w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/2-vertical-1-696x471.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/2-vertical-1-1068x723.jpg 1068w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/2-vertical-1-620x420.jpg 620w" sizes="(max-width: 641px) 100vw, 641px" /></p>
]]></content:encoded>
			<wfw:commentRss>https://www.acontecendoonline.com.br/acidente-grave-deixa-duas-vitimas-fatais-na-br-474-em-aimores-mg/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Motorista de caminhonete morre e dois ficam feridos em colisão com carreta</title>
		<link>https://www.acontecendoonline.com.br/motorista-de-caminhonete-morre-e-dois-ficam-feridos-em-colisao-com-carreta/</link>
		<comments>https://www.acontecendoonline.com.br/motorista-de-caminhonete-morre-e-dois-ficam-feridos-em-colisao-com-carreta/#respond</comments>
		<pubDate>Sun, 06 May 2018 23:41:28 +0000</pubDate>
		<dc:creator><![CDATA[AGÊNCIA ANVA]]></dc:creator>
				<category><![CDATA[Nacionais]]></category>
		<category><![CDATA[Polícia]]></category>

		<guid isPermaLink="false">https://www.acontecendoonline.com.br/?p=13925</guid>
		<description><![CDATA[<img width="788" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-1.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-1.jpg 788w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-1-300x200.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-1-768x512.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-1-696x464.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-1-630x420.jpg 630w" sizes="(max-width: 788px) 100vw, 788px" />Corpo de Bombeiros precisou retirar passageiro das ferragens. Acidente aconteceu na rodovia que liga Montes Claros ao Triângulo Mineiro O condutor de uma caminhonete morreu quando levava a família de Claro dos Poções para Montes Claros na manhã deste domingo (6) e foi atingido por uma carreta na BR-365 em Montes Claros, no Norte do [&#8230;]]]></description>
				<content:encoded><![CDATA[<img width="788" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-1.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-1.jpg 788w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-1-300x200.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-1-768x512.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-1-696x464.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-1-630x420.jpg 630w" sizes="(max-width: 788px) 100vw, 788px" /><h4>Corpo de Bombeiros precisou retirar passageiro das ferragens. Acidente aconteceu na rodovia que liga Montes Claros ao Triângulo Mineiro</h4>
<p>O condutor de uma caminhonete morreu quando levava a família de Claro dos Poções para Montes Claros na manhã deste domingo (6) e foi atingido por uma carreta na BR-365 em Montes Claros, no Norte do Estado. Segundo o Corpo de Bombeiros, o filho, de três anos, e a esposa da vítima sofreram lesões graves e foram conduzidos à Santa Casa de Montes Claros. O acidente aconteceu no km 38, que liga a cidade do Norte de Minas ao Triângulo Mineiro.</p>
<p><img class="wp-image-13927 alignleft" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/7a9ffd65-fb73-4c00-817d-ae2b9f93d36c-300x213.jpg" alt="" width="414" height="294" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/7a9ffd65-fb73-4c00-817d-ae2b9f93d36c-300x213.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/7a9ffd65-fb73-4c00-817d-ae2b9f93d36c-100x70.jpg 100w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/7a9ffd65-fb73-4c00-817d-ae2b9f93d36c-696x493.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/7a9ffd65-fb73-4c00-817d-ae2b9f93d36c-593x420.jpg 593w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/7a9ffd65-fb73-4c00-817d-ae2b9f93d36c.jpg 741w" sizes="(max-width: 414px) 100vw, 414px" />Francisco de Paula Fonseca, de 55 anos, ficou preso às ferragens e morreu antes da chegada do Corpo de Bombeiros. Ele dirigia uma Chevrolet D20 com placa de Montes Claros. O filho, de três anos, anos estava fora do veículo quando os militares chegaram. Ele estava se comunicando de maneira desconexa e apresentava lesões graves.</p>
<p>A esposa, de 46 anos, ainda estava presa às ferragens e precisou ser retirada pelos bombeiros também com ferimentos graves. Ambos foram socorridos pelo Serviço de Atendimento Móvel (Samu). Até esta publicação, o estado de saúde das vítimas encaminhadas à Santa Casa de Montes Claros não foi divulgado.</p>
<p>O motorista da carreta, de 39 anos, não teve nenhum ferimento e dispensou atendimento médico. O veículo tem placa de Naviraí, no Mato Grosso do Sul.</p>
<p>De acordo com o Corpo de Bombeiros, não há confirmações sobre as causas do acidente. A suspeita é de que o motorista da carreta tenha invadido a contramão e se chocado contra a caminhonete.</p>
<p>A Polícia Civil está no local para fazer a perícia. A Polícia Rodoviária Federal também acompanha a ocorrência.</p>
<p>Trânsito. Segundo a PRF, o trânsito foi bloqueado por volta das 5h da manhã e ficou completamente fechado por duas horas. A via foi totalmente liberada às 10h.</p>
<p><img class="wp-image-13922 aligncenter" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1-300x167.jpg" alt="" width="579" height="322" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1-300x167.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1-768x429.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1-1024x571.jpg 1024w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1-696x388.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1-1068x596.jpg 1068w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1-753x420.jpg 753w" sizes="(max-width: 579px) 100vw, 579px" /></p>
<p><img class="wp-image-13926 aligncenter" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-de-ok-13-300x179.jpg" alt="" width="592" height="353" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-de-ok-13-300x179.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-de-ok-13-768x458.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-de-ok-13-1024x611.jpg 1024w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-de-ok-13-696x415.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-de-ok-13-1068x637.jpg 1068w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-de-ok-13-704x420.jpg 704w" sizes="(max-width: 592px) 100vw, 592px" /></p>
]]></content:encoded>
			<wfw:commentRss>https://www.acontecendoonline.com.br/motorista-de-caminhonete-morre-e-dois-ficam-feridos-em-colisao-com-carreta/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Jovem morre em acidente com motocicleta na BR-259.</title>
		<link>https://www.acontecendoonline.com.br/jovem-morre-em-acidente-com-motocicleta-na-br-259/</link>
		<comments>https://www.acontecendoonline.com.br/jovem-morre-em-acidente-com-motocicleta-na-br-259/#respond</comments>
		<pubDate>Sun, 06 May 2018 16:11:52 +0000</pubDate>
		<dc:creator><![CDATA[AGÊNCIA ANVA]]></dc:creator>
				<category><![CDATA[Polícia]]></category>

		<guid isPermaLink="false">https://www.acontecendoonline.com.br/?p=13920</guid>
		<description><![CDATA[<img width="801" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/PhotoGrid_1525607855799-800x445.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/PhotoGrid_1525607855799-800x445.jpg 801w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/PhotoGrid_1525607855799-800x445-300x197.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/PhotoGrid_1525607855799-800x445-768x503.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/PhotoGrid_1525607855799-800x445-696x456.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/PhotoGrid_1525607855799-800x445-741x486.jpg 741w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/PhotoGrid_1525607855799-800x445-641x420.jpg 641w" sizes="(max-width: 801px) 100vw, 801px" />Segundo informações, o condutor da motocicleta Honda/CG 150 Fan identificado como Romildo Patrick de Oliveira Silva, de 26 anos, seguia de um churrasco em Baixo Guandu para o município de Aimorés/MG, por volta das 00h deste domingo. Ao chegar próximo ao Ibiza, o condutor teria perdido o controle da direção e colidido contra uma placa de sinalização. [&#8230;]]]></description>
				<content:encoded><![CDATA[<img width="801" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/PhotoGrid_1525607855799-800x445.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/PhotoGrid_1525607855799-800x445.jpg 801w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/PhotoGrid_1525607855799-800x445-300x197.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/PhotoGrid_1525607855799-800x445-768x503.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/PhotoGrid_1525607855799-800x445-696x456.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/PhotoGrid_1525607855799-800x445-741x486.jpg 741w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/PhotoGrid_1525607855799-800x445-641x420.jpg 641w" sizes="(max-width: 801px) 100vw, 801px" /><p>Segundo informações, o condutor da motocicleta Honda/CG 150 Fan identificado como Romildo Patrick de Oliveira Silva, de 26 anos, seguia de um churrasco em Baixo Guandu para o município de Aimorés/MG, por volta das 00h deste domingo. Ao chegar próximo ao Ibiza, o condutor teria perdido o controle da direção e colidido contra uma placa de sinalização. Com a força do impacto quatro estacas de madeira de uma cerca foram arrancadas.</p>
<p>Além do condutor estava na garupa da motocicleta uma mulher identificada como Liliane Karla Donadoni, de 34 anos, que morreu no local.</p>
<p>As duas vítimas foram encontradas pelo pai de um vereador do município. Ele estava indo pela manhã como de costume alimentar galinhas quando viu um boné caído na BR. Ao se aproximar do local, visualizou a mulher caída próxima à motocicleta. Já o condutor da motocicleta estava caído no meio do matagal.</p>
<p>Uma ambulância da Secretaria Municipal de Saúde socorreu o motociclista para o pronto-socorro local. O estado de saúde dele é estável.</p>
<p><img class=" wp-image-13923 aligncenter" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11-300x247.jpg" alt="" width="563" height="463" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11-300x247.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11-768x632.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11-1024x843.jpg 1024w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11-696x573.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11-1068x879.jpg 1068w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11-510x420.jpg 510w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-3-de-ok-11.jpg 1306w" sizes="(max-width: 563px) 100vw, 563px" /></p>
<p><img class="wp-image-13922 aligncenter" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1-300x167.jpg" alt="" width="564" height="314" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1-300x167.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1-768x429.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1-1024x571.jpg 1024w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1-696x388.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1-1068x596.jpg 1068w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1-753x420.jpg 753w" sizes="(max-width: 564px) 100vw, 564px" /></p>
]]></content:encoded>
			<wfw:commentRss>https://www.acontecendoonline.com.br/jovem-morre-em-acidente-com-motocicleta-na-br-259/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Blitz educativa de trânsito &#8220;Maio Amarelo&#8221; em Coronel Fabriciano</title>
		<link>https://www.acontecendoonline.com.br/blitz-educativa-de-transito-maio-amarelo-em-coronel-fabriciano/</link>
		<comments>https://www.acontecendoonline.com.br/blitz-educativa-de-transito-maio-amarelo-em-coronel-fabriciano/#respond</comments>
		<pubDate>Sun, 06 May 2018 15:21:21 +0000</pubDate>
		<dc:creator><![CDATA[AGÊNCIA ANVA]]></dc:creator>
				<category><![CDATA[Vale do Aço]]></category>

		<guid isPermaLink="false">https://www.acontecendoonline.com.br/?p=13912</guid>
		<description><![CDATA[<img width="800" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090601-1.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090601-1.jpg 800w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090601-1-300x197.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090601-1-768x504.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090601-1-696x457.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090601-1-741x486.jpg 741w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090601-1-640x420.jpg 640w" sizes="(max-width: 800px) 100vw, 800px" />O Maio Amarelo é um movimento internacional de conscientização para redução dos acidentes de trânsito. A escolha do mês de Maio foi motivada pela ONU – Organização das Nações Unidas, que desde 2.011 realiza um balanço anual das ações efetivadas em todo o mundo. Quanto as regras de trânsito. Em Coronel Fabriciano, os índices também [&#8230;]]]></description>
				<content:encoded><![CDATA[<img width="800" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090601-1.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090601-1.jpg 800w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090601-1-300x197.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090601-1-768x504.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090601-1-696x457.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090601-1-741x486.jpg 741w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090601-1-640x420.jpg 640w" sizes="(max-width: 800px) 100vw, 800px" /><p><img class=" wp-image-13917 alignright" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-de-figuras-09-300x199.jpg" alt="" width="189" height="125" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-de-figuras-09-300x199.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-de-figuras-09-768x509.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-de-figuras-09-1024x678.jpg 1024w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-de-figuras-09-696x461.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-de-figuras-09-741x486.jpg 741w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-de-figuras-09-634x420.jpg 634w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Cópia-de-figuras-09.jpg 1063w" sizes="(max-width: 189px) 100vw, 189px" />O Maio Amarelo é um movimento internacional de conscientização para redução dos acidentes de trânsito. A escolha do mês de Maio foi motivada pela ONU – Organização das Nações Unidas, que desde 2.011 realiza um balanço anual das ações efetivadas em todo o mundo. Quanto as regras de trânsito.</p>
<p><img class=" wp-image-13914 alignleft" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090011-300x169.jpg" alt="" width="377" height="211" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090011-300x169.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090011-768x432.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090011-696x392.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090011-746x420.jpg 746w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_090011.jpg 933w" sizes="(max-width: 377px) 100vw, 377px" />Em Coronel Fabriciano, os índices também são preocupantes, por isso precisamos ficar atentos e nos. Infelizmente em nossa cidade a educação no trânsito ainda precisa melhorar muito.</p>
<p>Neste sábado, 05/05, foi realizada uma blitz educativa de trânsito na avenida Magalhães Pinto, contou com participação ativa da Associação Comercial e Industrial e da Câmara de Dirigentes Lojistas &#8211; ACICEL/CDL;  Policia Militar, através do 58º Batalhão; Conselho da Mulher Empreendedora; Guarda Mirim; Clube do Jeep Vale do Aço e ainda com apoio de rotarianos que estiveram presentes ao evento.</p>
<p><img class=" wp-image-13883 alignright" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-300x167.jpg" alt="" width="332" height="184" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-300x167.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-768x429.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1024x571.jpg 1024w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-696x385.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1068x596.jpg 1068w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-753x420.jpg 753w" sizes="(max-width: 332px) 100vw, 332px" />O Vice prefeito de Fabriciano, Gregório da Retífica, também participou da blitz educativa oportunidade em que salientou a importância desta conscientização, parabenizando a ACICEL/CDL pelo trabalho realizado em campanhas educativas.</p>
<p>Os motoristas de Fabriciano, bem <img class=" wp-image-13782 alignright" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/slide-3-212x300.jpg" alt="" width="334" height="470" />como de outras cidades, devem ter mais paciência quando estiver ao volante. Dar preferência a quem está tentando entrar numa via preferencial,  ter calma quando alguém tenta estacionar, ser  cortês quando o carro da frente estiver com problemas. São coisas simples, mas que ajuda muito o fluxo e a harmonia no trânsito local.</p>
<p>Nosso jornal “acontecendoonline” está pronto a divulgar as informações que vierem contribuir para a melhoria de nosso trânsito, notícias, artigos, fotos,  é só passarem pelo email <a href="mailto:redação@acontecendoonline.com.br">redação@acontecendoonline.com.br</a></p>
]]></content:encoded>
			<wfw:commentRss>https://www.acontecendoonline.com.br/blitz-educativa-de-transito-maio-amarelo-em-coronel-fabriciano/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Presidente da Assembléia Legislativa exonera todos os indicados do PT</title>
		<link>https://www.acontecendoonline.com.br/presidente-da-assembleia-legislativa-exonera-todos-os-indicados-do-pt/</link>
		<comments>https://www.acontecendoonline.com.br/presidente-da-assembleia-legislativa-exonera-todos-os-indicados-do-pt/#respond</comments>
		<pubDate>Sun, 06 May 2018 00:14:19 +0000</pubDate>
		<dc:creator><![CDATA[AGÊNCIA ANVA]]></dc:creator>
				<category><![CDATA[Política]]></category>

		<guid isPermaLink="false">https://www.acontecendoonline.com.br/?p=13908</guid>
		<description><![CDATA[<img width="800" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505184900123232e.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505184900123232e.jpg 800w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505184900123232e-300x197.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505184900123232e-768x504.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505184900123232e-696x457.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505184900123232e-741x486.jpg 741w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505184900123232e-640x420.jpg 640w" sizes="(max-width: 800px) 100vw, 800px" />Corte de 62 comissionados foi publicado na edição deste sábado do Diário do Legislativo. Maioria dos exonerados era lotada na liderança do governo A edição deste sábado do Diário do Legislativo trouxe a exoneração de 62 funcionários comissionados lotados no Gabinete da Liderança do Governo e na Presidência da Assembleia Legislativa. As exonerações foram assinadas [&#8230;]]]></description>
				<content:encoded><![CDATA[<img width="800" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505184900123232e.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505184900123232e.jpg 800w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505184900123232e-300x197.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505184900123232e-768x504.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505184900123232e-696x457.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505184900123232e-741x486.jpg 741w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505184900123232e-640x420.jpg 640w" sizes="(max-width: 800px) 100vw, 800px" /><p><strong>Corte de 62 comissionados foi publicado na edição deste sábado do Diário do Legislativo. Maioria dos exonerados era lotada na liderança do governo</strong></p>
<p>A edição deste sábado do Diário do Legislativo trouxe a exoneração de 62 funcionários comissionados lotados no Gabinete da Liderança do Governo e na Presidência da Assembleia Legislativa. As exonerações foram assinadas pelo presidente da Casa, Adalclever Lopes (MDB).</p>
<p><img class=" wp-image-13883 alignright" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-300x167.jpg" alt="" width="483" height="267" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-300x167.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-696x385.jpg 696w" sizes="(max-width: 483px) 100vw, 483px" />Alguns dos comissionados lotados na Presidência eram cedidos para a liderança do governo. O líder do governo na Casa, Durval Ângelo, está viajando pelo interior e não foi localizado pela reportagem para comentar o assunto.</p>
<p>O rompimento das legendas no Legislativo começou com o acolhimento do pedido de impeachment contra o governador Fernando Pimentel – cuja tramitação está suspensa até terça-feira – e culminou com a aprovação da tese de candidatura própria do MDB ao Palácio da Liberdade, nas prévias realizadas no último dia 1º.</p>
<p>Logo após o encontro, o presidente do MDB estadual e vice-governador Antônio Andrade defendeu que os filiados do partido deveriam deixar os cargos ocupados no governo estadual – com exceção dele, porque foi “eleito democraticamente”.</p>
<p><img class=" wp-image-13910 aligncenter" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180504_150149-300x216.jpg" alt="" width="626" height="451" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180504_150149-300x216.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180504_150149-768x553.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180504_150149-1024x737.jpg 1024w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180504_150149-696x501.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180504_150149-1068x769.jpg 1068w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180504_150149-583x420.jpg 583w" sizes="(max-width: 626px) 100vw, 626px" /></p>
]]></content:encoded>
			<wfw:commentRss>https://www.acontecendoonline.com.br/presidente-da-assembleia-legislativa-exonera-todos-os-indicados-do-pt/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Nardyello é o candidato a Prefeito de Ipatinga pelo MDB</title>
		<link>https://www.acontecendoonline.com.br/nardyello-e-o-candidato-a-prefeito-de-ipatinga-pelo-mdb/</link>
		<comments>https://www.acontecendoonline.com.br/nardyello-e-o-candidato-a-prefeito-de-ipatinga-pelo-mdb/#respond</comments>
		<pubDate>Sat, 05 May 2018 23:31:45 +0000</pubDate>
		<dc:creator><![CDATA[AGÊNCIA ANVA]]></dc:creator>
				<category><![CDATA[Política]]></category>
		<category><![CDATA[Vale do Aço]]></category>

		<guid isPermaLink="false">https://www.acontecendoonline.com.br/?p=13900</guid>
		<description><![CDATA[<img width="799" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/grega-nardielo-nv.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/grega-nardielo-nv.jpg 799w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/grega-nardielo-nv-300x197.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/grega-nardielo-nv-768x505.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/grega-nardielo-nv-696x457.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/grega-nardielo-nv-741x486.jpg 741w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/grega-nardielo-nv-639x420.jpg 639w" sizes="(max-width: 799px) 100vw, 799px" />Maria de Lourdes Secretária do MDB de Fabriciano; Gregório vice prefeito MDB; Nardyello Rocha, Prefeito interino de Ipatinga e candidato do MDB e Carlão Campos, Presidente do MDB de Fabriciano.  (foto Agencia ANVA) A Convenção extraordinária do MDB de Ipatinga, realizada na tarde deste sábado no plenário da Câmara Municipal, aprovou o nome de Nardyello [&#8230;]]]></description>
				<content:encoded><![CDATA[<img width="799" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/grega-nardielo-nv.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/grega-nardielo-nv.jpg 799w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/grega-nardielo-nv-300x197.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/grega-nardielo-nv-768x505.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/grega-nardielo-nv-696x457.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/grega-nardielo-nv-741x486.jpg 741w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/grega-nardielo-nv-639x420.jpg 639w" sizes="(max-width: 799px) 100vw, 799px" /><p><em><strong>Maria de Lourdes Secretária do MDB de Fabriciano; Gregório vice prefeito MDB; Nardyello Rocha, Prefeito interino de Ipatinga e candidato do MDB e Carlão Campos, Presidente do MDB de Fabriciano.  </strong></em>(foto Agencia ANVA)</p>
<p>A Convenção extraordinária do MDB de Ipatinga, realizada na tarde deste sábado no plenário da Câmara Municipal, aprovou o nome de Nardyello Rocha como candidato do MDB à Prefeitura Municipal nas eleições extempor<img class="wp-image-13904 alignleft" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_153905-300x143.jpg" alt="" width="467" height="222" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_153905-300x143.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_153905-768x367.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_153905.jpg 1024w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_153905-696x332.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505_153905-880x420.jpg 880w" sizes="(max-width: 467px) 100vw, 467px" />âneas do próximo dia 03 de junho.</p>
<p>Além do MDB outros partidos também se coligaram, além de 14 vereadores que estão engajados no apoio a Nardyello.  A campanha começa na terça feira. Na oportunidade o ex prefeito Sebastião Quintão confirmou sua pré candidatura ao Senado federal pelo MDB.</p>
<p>O Vice Prefeito de Coronel Fabriciano, Gregório da Retífica, (MDB), esteve presente à convenção, juntamente com o Presidente <img class="wp-image-13883 alignright" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-300x167.jpg" alt="" width="365" height="203" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-300x167.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-768x429.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1024x571.jpg 1024w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-696x385.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1068x596.jpg 1068w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-753x420.jpg 753w" sizes="(max-width: 365px) 100vw, 365px" />Carlão Campos e a Secretária geral do diretório do MDB de Coronel Fabriciano, Maria de Lourdes.</p>
<p>Na oportunidade  o MDB de Fabriciano se colocou-se a disposição do candidato Nardyello Rocha para participar ativamente da campanha para o próximo dia 3 de junho.  Gregório, que é pre candidato a deputado <img class=" wp-image-13935 alignright" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/slide-01-robison-1-224x300.jpg" alt="" width="372" height="496" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/slide-01-robison-1-224x300.jpg 224w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/slide-01-robison-1-314x420.jpg 314w" sizes="(max-width: 372px) 100vw, 372px" />estadual pela sigla, reafirmou seu total apoio à Nardyello, acrescentando que &#8220;trata-se de pessoa honrada e de bons princípios, amigos dos humildes e nascido em Ipatinga&#8221;, concluiu Gregório.   Também o Presidente Carlão Campos e a Secretária Lourdes colocaram-se a disposição do candidato para a campanha eleitoral que se inicia na terça feira.</p>
<p>Nardyello é vereador pelo MDB e assumiu a presidência da Câmara de Ipatinga, passando a ocupar interinamente o cargo de prefeito municipal em substituição a Sebastião Quintão  que deixou a prefeitura por decisão judicial.</p>
<p><strong>VICE</strong></p>
<p>O atual secretário de administração da Prefeitura de Ipatinga Célio Francisco Aleixo será o vice na chapa de Nardyello Rocha, na coligação MDB-PV-PODEMOS-PROS-PTC-DEM-PTB-PEN-PSD-PPS-SOLIDARIEDADE-PSDB.</p>
<p>&nbsp;</p>
]]></content:encoded>
			<wfw:commentRss>https://www.acontecendoonline.com.br/nardyello-e-o-candidato-a-prefeito-de-ipatinga-pelo-mdb/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Acidente mata nove pessoas  no Paraná</title>
		<link>https://www.acontecendoonline.com.br/acidente-mata-nove-pessoas-no-parana/</link>
		<comments>https://www.acontecendoonline.com.br/acidente-mata-nove-pessoas-no-parana/#respond</comments>
		<pubDate>Sat, 05 May 2018 16:08:22 +0000</pubDate>
		<dc:creator><![CDATA[AGÊNCIA ANVA]]></dc:creator>
				<category><![CDATA[Nacionais]]></category>

		<guid isPermaLink="false">https://www.acontecendoonline.com.br/?p=13897</guid>
		<description><![CDATA[<img width="801" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505113433579039e.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505113433579039e.jpg 801w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505113433579039e-300x197.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505113433579039e-768x503.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505113433579039e-696x456.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505113433579039e-741x486.jpg 741w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505113433579039e-641x420.jpg 641w" sizes="(max-width: 801px) 100vw, 801px" />São Paulo &#8211; Um acidente entre um carro e um ônibus resultou na morte de nove pessoas, na manhã deste sábado, 5, na rodovia BR-373, altura do município de Candói, no Paraná, localizado na região de Ponta Grossa. O veículo teria tentado ultrapassagem e, na manobra, houve colisão frontal com o coletivo, que transportava mais [&#8230;]]]></description>
				<content:encoded><![CDATA[<img width="801" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505113433579039e.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505113433579039e.jpg 801w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505113433579039e-300x197.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505113433579039e-768x503.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505113433579039e-696x456.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505113433579039e-741x486.jpg 741w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/20180505113433579039e-641x420.jpg 641w" sizes="(max-width: 801px) 100vw, 801px" /><p>São Paulo &#8211; Um acidente entre um carro e um ônibus resultou na morte de nove pessoas, na manhã deste sábado, 5, na rodovia BR-373, altura do município de Candói, no Paraná, localizado na região de Ponta Grossa.</p>
<div class="row ads ads__with-bg hidden-print p-0 mb-35 mt-35">O veículo teria tentado ultrapassagem e, na manobra, houve colisã<img class=" wp-image-13882 alignright" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/slide-01-robison-224x300.jpg" alt="" width="356" height="476" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/slide-01-robison-224x300.jpg 224w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/slide-01-robison-768x1028.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/slide-01-robison-765x1024.jpg 765w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/slide-01-robison-696x932.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/slide-01-robison-1068x1430.jpg 1068w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/slide-01-robison-314x420.jpg 314w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/slide-01-robison.jpg 1177w" sizes="(max-width: 356px) 100vw, 356px" />o frontal com o coletivo, que transportava mais de 30 pacientes, beneficiários de um consórcio de saúde, de Curitiba para a cidade de Realeza.</p>
<p>Entre as vítimas fatais, segundo a Polícia Rodoviária Federal do Paraná (PRF-PR), estão o motorista e passageiro do carro e sete pessoas do ônibus. O condutor do automóvel chegou a ser levado ao Hospital Santa Clara de Candói. Após a triagem, teve de ser transferido para uma unidade em Guarapuava mas, no trajeto, não resistiu aos ferimentos.</p>
<p>Os demais feridos foram encaminhados ao Hospital Santa Clara de Candói e alguns transferidos para hospitais em Guarapuava e Coronel Vivida. Os carros foram retirados do local, liberando a via, e a perícia foi feita pelo Instituto Médico-Legal (IML) e o Instituto de Polícia Técnica.</p></div>
<div class="row ads ads__with-bg hidden-print p-0 mb-35 mt-35"><img class="wp-image-13727 aligncenter" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/b406c50f-b5dc-47bb-823c-77be6d35bb15-3-300x165.jpg" alt="" width="691" height="380" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/b406c50f-b5dc-47bb-823c-77be6d35bb15-3-300x165.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/b406c50f-b5dc-47bb-823c-77be6d35bb15-3-768x423.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/b406c50f-b5dc-47bb-823c-77be6d35bb15-3-1024x564.jpg 1024w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/b406c50f-b5dc-47bb-823c-77be6d35bb15-3-696x383.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/b406c50f-b5dc-47bb-823c-77be6d35bb15-3-1068x588.jpg 1068w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/b406c50f-b5dc-47bb-823c-77be6d35bb15-3-762x420.jpg 762w" sizes="(max-width: 691px) 100vw, 691px" /></div>
]]></content:encoded>
			<wfw:commentRss>https://www.acontecendoonline.com.br/acidente-mata-nove-pessoas-no-parana/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Painel debate formação da cidadania neste sábado em Timóteo</title>
		<link>https://www.acontecendoonline.com.br/painel-debate-formacao-da-cidadania-neste-sabado-em-timoteo/</link>
		<comments>https://www.acontecendoonline.com.br/painel-debate-formacao-da-cidadania-neste-sabado-em-timoteo/#respond</comments>
		<pubDate>Sat, 05 May 2018 01:04:45 +0000</pubDate>
		<dc:creator><![CDATA[AGÊNCIA ANVA]]></dc:creator>
				<category><![CDATA[Vale do Aço]]></category>

		<guid isPermaLink="false">https://www.acontecendoonline.com.br/?p=13894</guid>
		<description><![CDATA[<img width="778" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Hospital_Aereo_g.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Hospital_Aereo_g.jpg 778w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Hospital_Aereo_g-300x202.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Hospital_Aereo_g-768x518.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Hospital_Aereo_g-696x470.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Hospital_Aereo_g-622x420.jpg 622w" sizes="(max-width: 778px) 100vw, 778px" />Timóteo &#8211; Acontece neste sábado (5), a partir das 09 horas, no auditório do Metasita, no bairro Timirim, em Timóteo, o encerramento do Curso de Difusão do Conhecimento em Gestão Pública e Resistência ao Golpe. Para tanto, foi organizado o painel “Qual o papel da Escola, do Sindicato, do Partido e da Câmara Municipal na Formação [&#8230;]]]></description>
				<content:encoded><![CDATA[<img width="778" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Hospital_Aereo_g.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Hospital_Aereo_g.jpg 778w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Hospital_Aereo_g-300x202.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Hospital_Aereo_g-768x518.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Hospital_Aereo_g-696x470.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/Hospital_Aereo_g-622x420.jpg 622w" sizes="(max-width: 778px) 100vw, 778px" /><p style="font-weight: 400"><strong>Timóteo &#8211;</strong> Acontece neste sábado (5), a partir das 09 horas, no auditório do Metasita, no bairro Timirim, em Timóteo, o encerramento do Curso de Difusão do Conhecimento em Gestão Pública e Resistência ao Golpe.</p>
<p style="font-weight: 400">Para tanto, foi organizado o painel “Qual o papel da Escola, do Sindicato, do Partido e da Câmara Municipal na Formação da Cidadania?”. Os debatedores serão o professor do Unileste, Luiz Antônio da Silva, o metalúrgico Antônio Marcos, presidente do Metasita, o advogado Flaviano Dueli, presidente do PT de Timóteo, e o vereador Marcos da Luz (PT), de Coronel Fabriciano.</p>
<p style="font-weight: 400">Destinado a movimentos sociais e militantes da esquerda, o curso é uma iniciativa da Fundação Perseu Abramo, ligada à direção nacional do PT. Ao todo, cerca de 60 militantes da região participaram da formação, com carga horária de 110 horas, com aulas presencias e na plataforma <em>on-line</em>, sob a tutoria local do sociólogo Paulo Cruz, discutindo políticas públicas no Brasil e estratégias de organização pós-golpe.</p>
<p style="font-weight: 400">“O curso é uma mobilização dos movimentos sociais e parceiros na aglutinação de forças na resistência necessária ao golpe e no enfrentamento dos governos opressores e antidemocráticos. É uma oportunidade para unirmos forças e promovermos o debate do campo progressista”, ressalta o vereador Marcos da Luz.</p>
<p style="font-weight: 400">No encerramento, haverá a avaliação do curso, registro de sugestões e entrega dos certificados aos participantes.</p>
<p style="font-weight: 400"><img class="wp-image-13787 aligncenter" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/2-vertical-1-300x203.jpg" alt="" width="548" height="371" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/2-vertical-1-300x203.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/2-vertical-1-768x520.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/2-vertical-1-1024x693.jpg 1024w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/2-vertical-1-696x471.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/2-vertical-1-1068x723.jpg 1068w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/04/2-vertical-1-620x420.jpg 620w" sizes="(max-width: 548px) 100vw, 548px" /></p>
]]></content:encoded>
			<wfw:commentRss>https://www.acontecendoonline.com.br/painel-debate-formacao-da-cidadania-neste-sabado-em-timoteo/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Fitch eleva rating da Usiminas de B para B+ e melhora perspectiva para positiva</title>
		<link>https://www.acontecendoonline.com.br/fitch-eleva-rating-da-usiminas-de-b-para-b-e-melhora-perspectiva-para-positiva/</link>
		<comments>https://www.acontecendoonline.com.br/fitch-eleva-rating-da-usiminas-de-b-para-b-e-melhora-perspectiva-para-positiva/#respond</comments>
		<pubDate>Sat, 05 May 2018 00:25:37 +0000</pubDate>
		<dc:creator><![CDATA[AGÊNCIA ANVA]]></dc:creator>
				<category><![CDATA[Economia]]></category>

		<guid isPermaLink="false">https://www.acontecendoonline.com.br/?p=13891</guid>
		<description><![CDATA[<img width="790" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image.jpg 790w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-300x199.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-768x510.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-696x463.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-632x420.jpg 632w" sizes="(max-width: 790px) 100vw, 790px" />De acordo com a Fitch, a elevação do rating reflete &#8220;aprimoramentos contínuos&#8221; no perfil de crédito da siderúrgica A agência de classificação de risco Fitch elevou o rating da Usiminas de B para B+ e melhorou a perspectiva para a nota de crédito da empresa brasileira, de estável para positiva. De acordo com a Fitch, [&#8230;]]]></description>
				<content:encoded><![CDATA[<img width="790" height="525" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image.jpg" class="attachment-full size-full wp-post-image" alt="" style="float:left; margin:0 15px 15px 0;" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image.jpg 790w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-300x199.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-768x510.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-696x463.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/image-632x420.jpg 632w" sizes="(max-width: 790px) 100vw, 790px" /><header>
<div class="news-title"></div>
</header>
<div class="extra hidden-xs">
<p>De acordo com a Fitch, a elevação do rating reflete &#8220;aprimoramentos contínuos&#8221; no perfil de crédito da siderúrgica</p>
</div>
<div class="text">
<div class="articleBody">
<p>A agência de classificação de risco Fitch elevou o rating da Usiminas de B<img class=" wp-image-13882 alignright" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/slide-01-robison-224x300.jpg" alt="" width="321" height="428" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/slide-01-robison-224x300.jpg 224w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/slide-01-robison-314x420.jpg 314w" sizes="(max-width: 321px) 100vw, 321px" /> para B+ e melhorou a perspectiva para a nota de crédito da empresa brasileira, de estável para positiva.</p>
<p>De acordo com a Fitch, a elevação do rating reflete &#8220;aprimoramentos contínuos&#8221; no perfil de crédito da siderúrgica, apoiados por geração de fluxo de caixa operacional em ritmo &#8220;crescente&#8221; devido a &#8220;melhores preços e volumes, bem como ganhos de eficiência&#8221;.</p>
<p>Já a perspectiva positiva, explica a agência, é suportada pelas expectativas de que o perfil de crédito da Usiminas e a flexibilidade financeira da empresa &#8220;sejam ainda mais aprimorados&#8221; no médio prazo.</p>
<p><img class="wp-image-13883 alignright" src="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-300x167.jpg" alt="" width="663" height="369" srcset="https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-300x167.jpg 300w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-768x429.jpg 768w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1024x571.jpg 1024w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-696x388.jpg 696w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-1068x596.jpg 1068w, https://www.acontecendoonline.com.br/wp-content/uploads/2018/05/JERRY-753x420.jpg 753w" sizes="(max-width: 663px) 100vw, 663px" /></p>
</div>
</div>
]]></content:encoded>
			<wfw:commentRss>https://www.acontecendoonline.com.br/fitch-eleva-rating-da-usiminas-de-b-para-b-e-melhora-perspectiva-para-positiva/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
	</channel>
</rss>
";}')); /* Child Type: integer */ $data['createdOn'] = 1525703932;