<!DOCTYPE html><!--[if lt IE 7]><html class=\"lt-ie9 lt-ie8 lt-ie7\" xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\"><![endif]--><!--[if IE 7]><html class=\"lt-ie9 lt-ie8\" xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\"><![endif]--><!--[if IE 8]><html class=\"lt-ie9\" xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\"><![endif]--><!--[if gt IE 8]><!--><html xmlns=\"http://www.w3.org/1999/xhtml\"><!--<![endif]--><head><meta charset=\"utf-8\"/><meta name=\"HandheldFriendly\" content=\"True\"><meta name=\"MobileOptimized\" content=\"320\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no\"><meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\"/><link rel=\"apple-touch-icon\" sizes=\"57x57\" href=\"/pwa/apple-touch-icon-57x57.png\"><link rel=\"apple-touch-icon\" sizes=\"60x60\" href=\"/pwa/apple-touch-icon-60x60.png\"><link rel=\"apple-touch-icon\" sizes=\"72x72\" href=\"/pwa/apple-touch-icon-72x72.png\"><link rel=\"apple-touch-icon\" sizes=\"76x76\" href=\"/pwa/apple-touch-icon-76x76.png\"><link rel=\"apple-touch-icon\" sizes=\"114x114\" href=\"/pwa/apple-touch-icon-114x114.png\"><link rel=\"apple-touch-icon\" sizes=\"120x120\" href=\"/pwa/apple-touch-icon-120x120.png\"><link rel=\"apple-touch-icon\" sizes=\"144x144\" href=\"/pwa/apple-touch-icon-144x144.png\"><link rel=\"apple-touch-icon\" sizes=\"152x152\" href=\"/pwa/apple-touch-icon-152x152.png\"><link rel=\"apple-touch-icon\" sizes=\"180x180\" href=\"/pwa/apple-touch-icon-180x180.png\"><link rel=\"icon\" type=\"image/png\" sizes=\"32x32\" href=\"/pwa/favicon-32x32.png\"><link rel=\"icon\" type=\"image/png\" sizes=\"192x192\" href=\"/pwa/android-chrome-192x192.png\"><link rel=\"icon\" type=\"image/png\" sizes=\"16x16\" href=\"/pwa/favicon-16x16.png\"><link rel=\"manifest\" href=\"/pwa/manifest.json\"><link rel=\"mask-icon\" href=\"/pwa/safari-pinned-tab.svg\" color=\"#005a9f\"><link rel=\"shortcut icon\" href=\"/pwa/favicon.ico\"><meta name=\"apple-mobile-web-app-title\" content=\"CarroAluguel\"><meta name=\"application-name\" content=\"CarroAluguel\"><meta name=\"msapplication-TileColor\" content=\"#005a9f\"><meta name=\"msapplication-TileImage\" content=\"/pwa/mstile-144x144.png\"><meta name=\"msapplication-config\" content=\"/pwa/browserconfig.xml\"><meta name=\"theme-color\" content=\"#005a9f\"><link rel=\"canonical\" href=\"\" /><title>Sucesso Recife loja Imbiribeira.</title><meta name=\"description\" content=\"Sucesso em Recife loja Imbiribeira. Aluguel de carros com preços especiais!\"/><meta name=\"language\" content=\"pt-br\"/><meta http-equiv=\"Expires\" content=\"10080\"/><style type=\"text/css\">.row {max-width: 1150px;}[type=\'text\'], [type=\'password\'], [type=\'date\'], [type=\'datetime\'], [type=\'datetime-local\'], [type=\'month\'], [type=\'week\'], [type=\'email\'], [type=\'number\'], [type=\'search\'], [type=\'tel\'], [type=\'time\'], [type=\'url\'], [type=\'color\'], textarea {height: 2.30rem !important;padding: .5rem !important;border: 1px solid #cacaca !important;margin: 0 !important;}label{line-height: normal !important;}h1,h2,h2,h3,h4,h5,h6,p{font-family: \'Raleway\', sans-serif;}@media only screen and (max-width: 768px) {body{font-family: \'Raleway\', sans-serif;}#menu-footer ul{float:right;width: 100%;margin:0;background-color: #FF7900;padding: 0 5px;}#menu-footer li{display: block;margin: 0;color: #FFFFFF;background-color: #FF7900;border: 1px solid #c0c0c0;text-align: center;}.link_footer{float:right;background-color: #FF7900;width: 100%;border: 1px solid #c0c0c0;text-align: center;}#input_form label{font-size: 11px;}#site_seguro{margin: 20px 0 0 0;}h1{font-size: 20px;text-align: center;font-weight:bold;line-height: normal;margin: 20px 0 5px 0;padding: 0;color: #0b71bf;}.frase_h1{font-size: 14px;text-align: center;font-weight:normal;line-height: 16px;color: #000000;display: block;margin: 0 auto 20px auto;}.frase_h1 span{background: url(\"//carroaluguel.tur.br/images/carroaluguel/lp-locadoras/underline_header.png\") no-repeat scroll center 18px transparent;display: inline-block;}.form_pesquisa{background-color: #007cdb;opacity:0.80;-moz-opacity: 0.80;filter: alpha(opacity=80);padding: 15px;border-radius: 15px;margin: 20px 20px}.form_pesquisa label{color:#a2ff00;margin: 10px 0;}.btn-pesquisa{width: 100%;background-color: #97f533;color: #005298;text-transform: uppercase;font-size: 15px;border-radius: 7px;margin: 9px 0;border:none;min-height: 50px;font-weight: bold;}.faixa_pesquisa_header{background: url(\"//carroaluguel.tur.br/images/carroaluguel/lp-locadoras/fundo_header.jpg\") no-repeat scroll center 0 transparent;padding: 20px 0;}}@media only screen and (min-width: 768px) {body{font-family: \'Raleway\', sans-serif;}#menu-footer ul{float:right;margin:0;background-color: #FF7900;padding: 0 5px;}#menu-footer li{display: inline-block;margin: 0;color: #FFFFFF;background-color: #FF7900;}.link_footer{float:right;background-color: #FF7900;}#input_form label{font-size: 12px;}#site_seguro{margin: 40px 0 0 60px;}header{border-top: 8px solid #005a9f;padding: 25px 0;}h1{font-size: 36px;text-align: center;font-weight:bold;line-height: normal;margin: 20px 0 5px 0;padding: 0;}.frase_h1{font-size: 0.9em;text-align: center;font-weight:normal;line-height: normal;display: block;margin: 0 auto 20px auto;}.frase_h1 span{background: url(\"//carroaluguel.tur.br/images/carroaluguel/lp-locadoras/underline_header.png\") no-repeat scroll center 18px transparent;display: inline-block;}.form_pesquisa{background-color: #007cdb;opacity:0.80;-moz-opacity: 0.80;filter: alpha(opacity=80);padding: 35px;border-radius: 15px;margin-bottom:60px !important;}.form_pesquisa label{color:#a2ff00;margin-bottom: 8px;}.btn-pesquisa{width: 100%;min-height: 65px;background-color: #97f533;color: #005298;text-transform: uppercase;font-size: 20px;border-radius: 7px;margin: 9px 0;border:none;font-weight: bold;}.faixa_pesquisa_header{background: url(\"//carroaluguel.tur.br/images/carroaluguel/lp-locadoras/fundo_header.jpg\") no-repeat scroll center 0 transparent;padding: 40px 0 0 0;}#float_pesquisa{padding: 0;border: none;background: transparent;box-shadow: none;}}.cor-clara a{color:#FFF;line-height: 1.5 !important;}.cor-escura a{color:#CCC;line-height: 1.5 !important;}footer .bg-footer{background-color: #0b71bf;padding:10px 0;clear:both;}footer h3{font-size:30px;color:#f8f800;margin:0 0 10px 30px;}footer p{font-size:12px;}footer .link-mais{margin-left: 30px;}footer .link-mais a, footer .link-mais a:visited {color: #DAE9FE;text-decoration: underline;}footer .links{background: url(\"//carroaluguel.tur.br/images/carroaluguel/footer/seta-h3.png\") no-repeat scroll 0 0 transparent;min-width: 200px;margin: 0 auto;text-align: left;}footer ul{margin-left: 30px;line-height: 1.4em;}footer .row .column, footer .row .columns{padding: 0px;}/* end footer *//* footer nav */#menu-footer{padding:0;margin:0;}#menu-footer a{display: inline-block;color: #FFFFFF;margin:7px 7px;font-weight: bold;text-align: center;background-color: #FF7900;font-size: 12px;}/*  end footer nav*//* Colunas  */.linha{max-width: 1000px;text-align: center;margin: 0 auto;margin-bottom: 10px;}.linha:after {content: \".\";display: block;height: 0;clear: both;visibility: hidden;}.coluna-3{min-width: 32%;margin: 0 auto;text-align: center;overflow:hidden;display: -moz-inline-stack;display: inline-block;vertical-align: top;zoom: 1;*display: inline;_height: 250px;}.coluna-3b{min-width: 32%;margin: 0 auto;text-align: center;display: inline-block;overflow:hidden;}.coluna-5{min-width: 19%;margin: 0 auto;text-align: center;overflow:hidden;display: -moz-inline-stack;display: inline-block;vertical-align: top;zoom: 1;*display: inline;_height: 250px;}ul, ol {list-style: none;clear:both;font-family:font-family: \'Raleway\', sans-serif;font-size:12px;color:#747576;}.barra_footer{background-color: rgb(237, 237, 237) !important;margin-bottom: 0 !important;padding: 20px !important;}.barra_footer .large-9{font-size: 12px;margin-top: 13px;}#devolver-outra{}#busca-carro input, #busca-carro_float input{padding:5px 25px 5px 5px!important;border-radius: 7px;height: 10px;}#busca-carro select, #busca-carro_float select{border-radius: 7px;margin-left: 3px;}#busca-carro_float select{margin-left: 0;margin-top: 3px;}#busca-carro_float label{color:#a2ff00;margin: 8px 0;font-weight: bold;}.text_form{color:#FFFFFF;font-size: 12px;}.icon_head{height:45px;}.icon_head_title{font-size: 15px;color:#005a9f;display: block;padding: 5px 0 0 50px;}.icon_head_desc{font-size: 11px;color:#595959;display: block;padding: 3px 0 3px 50px;line-height: 16px;}.sprite_header{display: inline-block;float: left;width: 45px;height: 45px;background: url(//carroaluguel.tur.br/images/carroaluguel/lp-locadoras/sprite_lp_locadoras.png) no-repeat;margin: 0 auto;vertical-align: middle;}.sprite_header_chat{background-position: 0 0 !important;}.sprite_header_cliente{background-position: -45px 0 !important;}.sprite_header_contato{background-position: -90px 0 !important;}.sprite_protecao{background-position: -135px 0 !important;}.sprite_lp_set{display: block;margin: 3px auto;width: 25px;height: 25px;background: url(//carroaluguel.tur.br/images/carroaluguel/lp-locadoras/sprite_lp_locadoras.png) no-repeat;vertical-align: middle;}.sprite_lp_set_calendar{background-position: 0 -45px !important;}.sprite_lp_set_clock{background-position: -25px -45px !important;}.sprite_lp_set_setas{background-position: -50px -45px !important;}.sprite_lp_set_check{background-position: -75px -45px !important;display: inline-block;}.orbit-container .orbit-prev{background: url(//carroaluguel.tur.br/images/carroaluguel/lp-locadoras/seta_orbit_left.png) no-repeat;color:transparent !important;height:60px;}.orbit-container .orbit-next {background: url(//carroaluguel.tur.br/images/carroaluguel/lp-locadoras/seta_orbit_right.png) no-repeat;color:transparent !important;height:60px;}.orbit-container span {border:none !important;}.orbit-slide-number{display:none;}.orbit-timer{display:none;}.lojas_selecionadas{display: none;}#map_canvas {display: block;width: 100%;height: 180px;margin: 0 0 10px 0;}.ui-widget {font-size:12px !important;}.ui-datepicker{font-size:11px !important;width: 195px;padding:0;}.ui-datepicker th{font-size:11px !important;padding:2px !important;}.ui-datepicker select{height: 17px !important;padding: 0 !important;width: 38px;}.ui-datepicker table tr td{font-size:11px !important;padding:0;}.timeselect{font-size:10px !important;}.ui-datepicker-buttonpane button{border:1px solid #45930B;}.tabela_precos{display: block;background-color: #5a5852;opacity:0.80;-moz-opacity: 0.80;filter: alpha(opacity=80);width: 350px;height: 137px;margin-left: 115px;border: 1px transparent;border-radius: 10px;padding: 15px 25px;}.title_tabela_precos{color: #a2ff00;font-size: 14px;text-transform: uppercase;font-weight: bold;}.precos_tabela_precos{color: #FFFFFF;font-size: 14px;}.link_tabela_precos{color: #000000;font-size: 12px;}.reveal{background: none!important;border:none !important;}.field_calendario{background: url(//carroaluguel.tur.br/images/carroaluguel/lp-locadoras/icone_calendario.png) no-repeat 94% 7px !important;background-color: #FFFFFF !important;}.field_horario{background: url(//carroaluguel.tur.br/images/carroaluguel/lp-locadoras/icone_relogio.png) no-repeat 94% 7px !important;background-color: #FFFFFF !important;}.reveal-modal .close-reveal-modal{z-index: 10000;color: #FFFFFF;}.picker__button--clear, .picker__button--close, .picker__button--today{color: #000000 !important;}.picker__select--month {padding:0 !important;font-size: .75em !important;}.root-picker-outlet{z-index: 1000;position:fixed;top:0;left:0}.ajuste_tamanho_header{max-width: 72.78rem !important;}</style><!-- Facebook Pixel Code --><script>!function(f,b,e,v,n,t,s){if(f.fbq)return;n=f.fbq=function(){n.callMethod?n.callMethod.apply(n,arguments):n.queue.push(arguments)};if(!f._fbq)f._fbq=n;n.push=n;n.loaded=!0;n.version=\'2.0\';n.queue=[];t=b.createElement(e);t.async=!0;t.src=v;s=b.getElementsByTagName(e)[0];s.parentNode.insertBefore(t,s)}(window,document,\'script\',\'https://connect.facebook.net/en_US/fbevents.js\');fbq(\'init\', \'1492763194308766\');fbq(\'track\', \"PageView\");</script><noscript><img height=\"1\" width=\"1\" style=\"display:none\"src=\"https://www.facebook.com/tr?id=1492763194308766&ev=PageView&noscript=1\"/></noscript><!-- End Facebook Pixel Code --></head><body><!-- BEGIN Google Analytics //--><script>(function(i,s,o,g,r,a,m){i[\'GoogleAnalyticsObject\']=r;i[r]=i[r]||function(){(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)})(window,document,\'script\',\'//www.google-analytics.com/analytics.js\',\'ga\');ga(\'create\', \'UA-3263959-3\', \'auto\');ga(\'send\', \'pageview\');</script><!-- END Google Analytics //--><!-- UET BING //--><script>(function(w,d,t,r,u){var f,n,i;w[u]=w[u]||[],f=function(){var o={ti:\"5039828\"};o.q=w[u],w[u]=new UET(o),w[u].push(\"pageLoad\")},n=d.createElement(t),n.src=r,n.async=1,n.onload=n.onreadystatechange=function(){var s=this.readyState;s&&s!==\"loaded\"&&s!==\"complete\"||(f(),n.onload=n.onreadystatechange=null)},i=d.getElementsByTagName(t)[0],i.parentNode.insertBefore(n,i)})(window,document,\"script\",\"//bat.bing.com/bat.js\",\"uetq\");</script><noscript><img src=\"//bat.bing.com/action/0?ti=5039828&Ver=2\" height=\"0\" width=\"0\" style=\"display:none; visibility: hidden;\" /></noscript><!-- END UET BING //--><header><div class=\"traco_azul_top hide-for-large-up hide-for-medium\">&nbsp</div><div class=\"row collapse ajuste_tamanho_header\"><div class=\"small-6 medium-5 large-5 columns \"><div class=\"row\"><div class=\"small-12 medium-12 large-12 columns\"><a href=\"http://www.carroaluguel.com\"><img id=\"logo\" class=\"ajuste_tamanho_logo\" src=\"//www.carroaluguel.tur.br/images/carroaluguel/funilreservas/logo.png\" style=\"border: none;\" alt=\"CarroAluguel.com - A melhor maneira de alugar um carro\"/></a></div></div></div><div class=\"small-6 medium-7 large-7 columns\"><div class=\"row collapse\"><div class=\"small-12 large-4 columns head_contato show-for-medium-up hide-for-medium-only\" onclick=\"window.open(\'https://www.carroaluguel.com/suporte/chat.php?acid=bdeed\',\'\',\'width=600,height=760,left=0,top=0,resizable=yes,menubar=no,location=no,status=yes,scrollbars=yes\')\" style=\"cursor:pointer\"><div class=\"icon_head\" style=\"line-height: 10px;\"><span class=\"sprite_header sprite_header_chat\"></span><span class=\"icon_head_title\" style=\"padding: 12px 0 0 50px;\">Dúvidas?</span><span class=\"icon_head_desc\">Acesse o chat</span></div></div><div class=\"small-12 medium-6 large-4 columns head_contato hide-for-small hide-for-medium\" style=\"cursor:pointer\" onclick=\"window.location=\'https://www.carroaluguel.com/cliente\'\"><div class=\"icon_head\" style=\"width: 175px;\"><span class=\"sprite_header sprite_header_cliente\"></span><span class=\"icon_head_title\" style=\"padding: 12px 0 0 50px;\">Área do cliente</span></div></div><div class=\"small-12 medium-6 large-4 columns head_contato show-for-medium-up\" style=\"cursor:pointer\" onclick=\"window.location=\'https://www.carroaluguel.com/telefones-atendimento\'\"><div class=\"icon_head\" style=\"line-height: 10px;\"><span class=\"sprite_header sprite_header_contato\"></span><span class=\"icon_head_title\" id=\"fone_number\" style=\"padding: 12px 0 0 50px;\">4062 0633</span><span class=\"icon_head_desc\">Acessar área de contatos</span></div></div></div></div></div></header><div class=\"row\" xmlns=\"http://www.w3.org/1999/html\"><div class=\"root-picker-outlet\"></div><input type=\"hidden\" id=\"valor_id_cidade\" name=\"valor_id_cidade\" value=\"5406\"/><div id=\"float_pesquisa\" class=\"reveal-modal large\" data-reveal aria-labelledby=\"modalTitle\" aria-hidden=\"true\" role=\"dialog\"><a id=\"close_float_pesquisa\" class=\"close-reveal-modal\" aria-label=\"Close\">&#215;</a><div id=\"float_pesquisa_content reveal-modal_mbl\"><div class=\"row collapse form-pesquisa-geral\"><div class=\"medium-12 large-12 columns\"><div class=\"row form_pesquisa_modal\"><form name=\"busca-carro_float\" id=\"busca-carro_float\" method=\"get\" action=\"https://www.carroaluguel.com/pesquisa-loja-float\"><div class=\"small-12 medium-6 large-6 columns col-dados1 \"><div class=\"row\"><div class=\"small-12 medium-12 large-12 columns\"><label for=\"retirar_cidade_float\"><strong>Retirar carro em:</strong></label><input type=\"text\" name=\"retirar_cidade_float\" id=\"retirar_cidade_float\" class=\"autocomplete-cidade float_pesquisa_ne\" value=\"Recife-PE\" readonly><input type=\"button\" name=\"limpa_texto\" id=\"limpa_texto\" class=\"botao_limpador_float\" onclick=\"limpador_texto_cidade_float()\"><input type=\"hidden\" name=\"aero_retirada_float\" id=\"aero_retirada_float\" value=\"\"><input type=\"hidden\" name=\"sel_bairro_float\" id=\"sel_bairro\" value=\"\"><input type=\"hidden\" id=\"retirar_cidade-cid_principal_float\" name=\"retirar_cidade-cid_principal_float\" value=\"5406\"><input type=\"hidden\" id=\"retirar_cidade-ref_principal_float\" name=\"retirar_cidade-ref_principal_float\" value=\"cidade\"><input type=\"hidden\" id=\"retirar_cidade-val_principal_float\" name=\"retirar_cidade-val_principal_float\" value=\"5406\"></div><div class=\"small-12 medium-12 large-6 columns\"><label class=\"data\">Retirada</label><input type=\"text\" name=\"dataRetirada_float\" id=\"dataRetirada_float\" class=\"validate[required] data_retirada\" value=\"\"/><select name=\"horaRetirada_float\" id=\"horaRetirada_float\" class=\"postfix validate[required]\"><option value=\"00:00\">00:00</option><option value=\"00:30\">00:30</option><option value=\"01:00\">01:00</option><option value=\"01:30\">01:30</option><option value=\"02:00\">02:00</option><option value=\"02:30\">02:30</option><option value=\"03:00\">03:00</option><option value=\"03:30\">03:30</option><option value=\"04:00\">04:00</option><option value=\"04:30\">04:30</option><option value=\"05:00\">05:00</option><option value=\"05:30\">05:30</option><option value=\"06:00\">06:00</option><option value=\"06:30\">06:30</option><option value=\"07:00\">07:00</option><option value=\"07:30\">07:30</option><option value=\"08:00\">08:00</option><option value=\"08:30\">08:30</option><option value=\"09:00\">09:00</option><option value=\"09:30\">09:30</option><option value=\"10:00\">10:00</option><option value=\"10:30\">10:30</option><option value=\"11:00\">11:00</option><option value=\"11:30\">11:30</option><option value=\"12:00\">12:00</option><option value=\"12:30\">12:30</option><option value=\"13:00\">13:00</option><option value=\"13:30\">13:30</option><option value=\"14:00\">14:00</option><option value=\"14:30\">14:30</option><option value=\"15:00\">15:00</option><option value=\"15:30\">15:30</option><option value=\"16:00\">16:00</option><option value=\"16:30\">16:30</option><option value=\"17:00\">17:00</option><option value=\"17:30\">17:30</option><option value=\"18:00\">18:00</option><option value=\"18:30\">18:30</option><option value=\"19:00\">19:00</option><option value=\"19:30\">19:30</option><option value=\"20:00\">20:00</option><option value=\"20:30\">20:30</option><option value=\"21:00\">21:00</option><option value=\"21:30\">21:30</option><option value=\"22:00\">22:00</option><option value=\"22:30\">22:30</option><option value=\"23:00\">23:00</option><option value=\"23:30\">23:30</option></select></div><div class=\"large-6 small-12 columns\"><label class=\"data\">Devolução</label><input type=\"text\" name=\"dataDevolucao_float\" id=\"dataDevolucao_float\" class=\"validate[required] date-devolucao\" value=\"\"/><select name=\"horaDevolucao_float\" id=\"horaDevolucao_float\" class=\"postfix validate[required]\"><option value=\"00:00\">00:00</option><option value=\"00:30\">00:30</option><option value=\"01:00\">01:00</option><option value=\"01:30\">01:30</option><option value=\"02:00\">02:00</option><option value=\"02:30\">02:30</option><option value=\"03:00\">03:00</option><option value=\"03:30\">03:30</option><option value=\"04:00\">04:00</option><option value=\"04:30\">04:30</option><option value=\"05:00\">05:00</option><option value=\"05:30\">05:30</option><option value=\"06:00\">06:00</option><option value=\"06:30\">06:30</option><option value=\"07:00\">07:00</option><option value=\"07:30\">07:30</option><option value=\"08:00\">08:00</option><option value=\"08:30\">08:30</option><option value=\"09:00\">09:00</option><option value=\"09:30\">09:30</option><option value=\"10:00\">10:00</option><option value=\"10:30\">10:30</option><option value=\"11:00\">11:00</option><option value=\"11:30\">11:30</option><option value=\"12:00\">12:00</option><option value=\"12:30\">12:30</option><option value=\"13:00\">13:00</option><option value=\"13:30\">13:30</option><option value=\"14:00\">14:00</option><option value=\"14:30\">14:30</option><option value=\"15:00\">15:00</option><option value=\"15:30\">15:30</option><option value=\"16:00\">16:00</option><option value=\"16:30\">16:30</option><option value=\"17:00\">17:00</option><option value=\"17:30\">17:30</option><option value=\"18:00\">18:00</option><option value=\"18:30\">18:30</option><option value=\"19:00\">19:00</option><option value=\"19:30\">19:30</option><option value=\"20:00\">20:00</option><option value=\"20:30\">20:30</option><option value=\"21:00\">21:00</option><option value=\"21:30\">21:30</option><option value=\"22:00\">22:00</option><option value=\"22:30\">22:30</option><option value=\"23:00\">23:00</option><option value=\"23:30\">23:30</option></select></div></div></div><div class=\"small-12 medium-6 large-6  columns col-dados2\"><div class=\"row\"><div class=\"small-12 medium-12 large-12  columns\"><div><label for=\"devolver_float\"><input type=\"checkbox\" value=\"1\" name=\"devolver_float\" id=\"devolver-outra_float\" onclick=\"check_outro_local_modal(this)\"/> Devolver em cidade diferente</label><div class=\"cidade_devolucao_float_modal hide\"><input type=\"text\" name=\"cidade_devolucao_float\" id=\"cidade_devolucao_float\" value=\"\" class=\"autocomplete-cidade float_pesquisa_ne2\" /></div></div><button type=\"submit\" class=\"btn-pesquisa_modal\"><img src=\"/images/form_pesquisa_busca.png\"/> Pesquisar os melhores preços</button></div></div></div></form></div></div></div></div></div><div id=\"float_pesquisa_mbl\" class=\"reveal-modal large\" data-reveal aria-labelledby=\"modalTitle\" aria-hidden=\"true\" role=\"dialog\" style=\"background-color: transparent;\"><a id=\"close_float_pesquisa\" class=\"close-reveal-modal\" aria-label=\"Close\">&#215;</a><div id=\"float_pesquisa_content reveal-modal_mbl\" style=\"background-color: #0b71bf; border-radius: 10px;\"><div class=\"row collapse form-pesquisa-geral\"><div class=\"medium-12 large-12 columns\"><div class=\"row form_pesquisa_modal\"><form name=\"busca-carro_float\" id=\"busca-carro_float\" method=\"get\" action=\"https://www.carroaluguel.com/pesquisa-cidade-mbl\"><div class=\"small-12 medium-6 large-6 columns col-dados1 \"><div class=\"row\"><div class=\"small-12 medium-12 large-12 columns\"><label for=\"retirar_cidade_float\"><strong>Retirar carro em:</strong></label><input type=\"text\" name=\"retirar_cidade_float_mbl\" id=\"retirar_cidade_float_mbl\" class=\"autocomplete-cidade modal_mbl_ne\" value=\"Recife-PE\" onclick=\"if(this.value==\'Digite a cidade\'){this.value=\'\'}\" onblur=\"if(this.value==\'\'){this.value=\'Digite a cidade\'}\" readonly/><input type=\"button\" name=\"limpa_texto\" id=\"limpa_texto\" class=\"mbl_botao_limpador_float\" onclick=\"limpador_retira_cidade_mbl_ne_float()\"><input type=\"hidden\" name=\"aero_retirada_float_mbl\" id=\"aero_retirada_float_mbl\" value=\"\"><input type=\"hidden\" name=\"sel_bairro_float_mbl\" id=\"sel_bairro_float_mbl\" value=\"\"><input type=\"hidden\" id=\"retirar_cidade-cid_float_mbl\" name=\"retirar_cidade-cid_float_mbl\" value=\"5406\"><input type=\"hidden\" id=\"retirar_cidade-ref_float_mbl\" name=\"retirar_cidade-ref_float_mbl\" value=\"cidade\"><input type=\"hidden\" id=\"retirar_cidade-val_float_mbl\" name=\"retirar_cidade-val_float_mbl\" value=\"5406\"></div><div class=\"small-12 medium-12 large-6 columns\"><label class=\"data\">Retirada</label><input type=\"text\" name=\"dataRetirada_float_mbl\" id=\"dataRetirada_float_mbl\" class=\"validate[required] data_retirada\" value=\"\"/><select name=\"horaRetirada_float_mbl\" id=\"horaRetirada_float_mbl\" class=\"postfix validate[required] mbl_horaRetirada_float\"><option value=\"00:00\">00:00</option><option value=\"00:30\">00:30</option><option value=\"01:00\">01:00</option><option value=\"01:30\">01:30</option><option value=\"02:00\">02:00</option><option value=\"02:30\">02:30</option><option value=\"03:00\">03:00</option><option value=\"03:30\">03:30</option><option value=\"04:00\">04:00</option><option value=\"04:30\">04:30</option><option value=\"05:00\">05:00</option><option value=\"05:30\">05:30</option><option value=\"06:00\">06:00</option><option value=\"06:30\">06:30</option><option value=\"07:00\">07:00</option><option value=\"07:30\">07:30</option><option value=\"08:00\">08:00</option><option value=\"08:30\">08:30</option><option value=\"09:00\">09:00</option><option value=\"09:30\">09:30</option><option value=\"10:00\">10:00</option><option value=\"10:30\">10:30</option><option value=\"11:00\">11:00</option><option value=\"11:30\">11:30</option><option value=\"12:00\">12:00</option><option value=\"12:30\">12:30</option><option value=\"13:00\">13:00</option><option value=\"13:30\">13:30</option><option value=\"14:00\">14:00</option><option value=\"14:30\">14:30</option><option value=\"15:00\">15:00</option><option value=\"15:30\">15:30</option><option value=\"16:00\">16:00</option><option value=\"16:30\">16:30</option><option value=\"17:00\">17:00</option><option value=\"17:30\">17:30</option><option value=\"18:00\">18:00</option><option value=\"18:30\">18:30</option><option value=\"19:00\">19:00</option><option value=\"19:30\">19:30</option><option value=\"20:00\">20:00</option><option value=\"20:30\">20:30</option><option value=\"21:00\">21:00</option><option value=\"21:30\">21:30</option><option value=\"22:00\">22:00</option><option value=\"22:30\">22:30</option><option value=\"23:00\">23:00</option><option value=\"23:30\">23:30</option></select></div><div class=\"large-6 small-12 columns\"><label class=\"data\">Devolução</label><input type=\"text\" name=\"dataDevolucao_float_mbl\" id=\"dataDevolucao_float_mbl\" class=\"validate[required] date-devolucao\" value=\"\"/><select name=\"horaDevolucao_float_mbl\" id=\"horaDevolucao_float_mbl\" class=\"postfix validate[required] mbl_horaDevolucao_float\"><option value=\"00:00\">00:00</option><option value=\"00:30\">00:30</option><option value=\"01:00\">01:00</option><option value=\"01:30\">01:30</option><option value=\"02:00\">02:00</option><option value=\"02:30\">02:30</option><option value=\"03:00\">03:00</option><option value=\"03:30\">03:30</option><option value=\"04:00\">04:00</option><option value=\"04:30\">04:30</option><option value=\"05:00\">05:00</option><option value=\"05:30\">05:30</option><option value=\"06:00\">06:00</option><option value=\"06:30\">06:30</option><option value=\"07:00\">07:00</option><option value=\"07:30\">07:30</option><option value=\"08:00\">08:00</option><option value=\"08:30\">08:30</option><option value=\"09:00\">09:00</option><option value=\"09:30\">09:30</option><option value=\"10:00\">10:00</option><option value=\"10:30\">10:30</option><option value=\"11:00\">11:00</option><option value=\"11:30\">11:30</option><option value=\"12:00\">12:00</option><option value=\"12:30\">12:30</option><option value=\"13:00\">13:00</option><option value=\"13:30\">13:30</option><option value=\"14:00\">14:00</option><option value=\"14:30\">14:30</option><option value=\"15:00\">15:00</option><option value=\"15:30\">15:30</option><option value=\"16:00\">16:00</option><option value=\"16:30\">16:30</option><option value=\"17:00\">17:00</option><option value=\"17:30\">17:30</option><option value=\"18:00\">18:00</option><option value=\"18:30\">18:30</option><option value=\"19:00\">19:00</option><option value=\"19:30\">19:30</option><option value=\"20:00\">20:00</option><option value=\"20:30\">20:30</option><option value=\"21:00\">21:00</option><option value=\"21:30\">21:30</option><option value=\"22:00\">22:00</option><option value=\"22:30\">22:30</option><option value=\"23:00\">23:00</option><option value=\"23:30\">23:30</option></select></div></div></div><div class=\"small-12 medium-6 large-6  columns col-dados2\"><div class=\"row\"><div class=\"small-12 medium-12 large-12  columns\"><div><label for=\"devolver_float\"><input type=\"checkbox\" value=\"1\" name=\"devolver_float\" id=\"devolver-outra_float_mbl\" class=\"arruma_check_mbl_modal\"  onclick=\"check_outro_local_mbl_modal(this)\"/> <span style=\"margin-top: -30px; margin-left: 20px; display: block;\"> Devolver em cidade diferente</span></label><input type=\"text\" name=\"cidade_devolucao_float_mbl\" id=\"cidade_devolucao_float_mbl\" value=\"\" class=\"autocomplete-cidade hide_mbl mbl_hide_modal\" disabled/></div><button type=\"submit\" class=\"btn-pesquisa_modal mudaCor_btn\" style=\"margin-top: 20px; border-radius: 7px;\"><img src=\"/images/form_pesquisa_busca.png\"/> Pesquisar os melhores preços</button></div></div></div></form></div></div></div></div></div><div id=\"modalOutroLocal\" class=\"reveal-modal large\" data-reveal aria-labelledby=\"modalTitle\" aria-hidden=\"true\" role=\"dialog\"><a id=\"close_modal_outrosLocais\" class=\"close-reveal-modal xis_fechar\" aria-label=\"Close\">&#215;</a><div id=\"float_modalOutrolocal\"><div class=\"row collapse form-pesquisa-geral\"><div class=\"medium-12 large-12 columns\"><div class=\"row\"><div class=\"titulo_modalOutrolocal\"> Outras lojas da Sucesso Rent a Car em Recife:</div></div><div class=\"row\"><img src=\"//www.carroaluguel.com/images/carroaluguel/icone_cidade_carro.png\"> </img><a href=\"/sucesso-rent-a-car/recife/imbiribeira\" style=\"margin-left: 10px;\">Locadora Sucesso Rent a Car Recife, Imbiribeira</a></div><hr><div class=\"row\"><img src=\"//www.carroaluguel.com/images/carroaluguel/icone_aeroporto_carro.png\" style=\"margin-left: -3px;\"> </img><a href=\"/sucesso-rent-a-car/recife/aeroporto-internacional-de-recife-guararapes-gilberto-freyre\" style=\"margin-left: 10px;\">Locadora Sucesso Rent a Car Recife, Aeroporto Internacional de Recife - Guararapes - Gilberto Freyre</a></div><hr></div></div></div></div><div class=\"small-12 columns mbl_arruma_fundo\"><div class=\"faixa_pesquisa_header\" style=\"padding:20px 0 0\"><div class=\"small-12 columns\"><input type=\"hidden\" id=\"tamanho_h1_cima\" name=\"tamanho_h1_cima\" value=\"1\"/><input type=\"hidden\" id=\"mbl_check\" name=\"mbl_check\" value=\"0\"/><h1 class=\"h1_locadora_loja mbl_h1_locadora_loja\" value=\"-\"> -<spam class=\"h1_locadora_loja_baixo mbl_h1_locadora_loja_baixo\">Av. Mal. Mascarenhas de Morais - Imbiribeira</spam></h1></div><div class=\"small-12 columns mbl_fundo_sprite hide-for-large-up\"><span class=\"mbl_sprite_logo_locadoras mbl_sprite_sucesso-rent-a-car\" style=\"margin-left: 76.3%;\" title=\"Movida Rent a Car\"></span></div><form itemscope=\"\" itemtype=\"http://schema.org/RentalCarReservation\" name=\"busca-carro\" id=\"busca-carro\" method=\"get\" action=\"https://www.carroaluguel.com/resultado\"><div class=\"small-12 columns mbl_fundo_pesquisa\"><div class=\"row collapse form_pesquisa form_pesquisa_cor_\"><div class=\"row collapse mbl_form_pesquisa form_pesquisa_cor_ hide-for-large-up\"><div class=\"small-12 columns mbl_pesquisa form_pesquisa_cor_\"><div class=\"row\"><span class=\"mbl_escolha\">Escolha onde retirar o carro</span></div><div class=\"row\"><input type=\"text\" name=\"mbl_retirar_cidade\" id=\"mbl_retirar_cidade\" class=\"autocomplete-cidade mbl_retirar_cidade\" value=\"Recife-PE\" onclick=\"if(this.value==\'Digite a cidade\'){this.value=\'\'}\"onblur=\"if(this.value==\'\'){this.value=\'Digite a cidade\'}\" placeholder=\"Digite a cidade, bairro ou aeroporto\" readonly><input type=\"button\" name=\"limpa_texto\" id=\"limpa_texto\" class=\"botao_limpador_mbl_ne\" onclick=\"limpador_retira_cidade_mbl_ne()\"><input type=\"hidden\" id=\"retirar_cidade-cid_mbl\" name=\"retirar_cidade-cid_mbl\" value=\"5406\"><input type=\"hidden\" id=\"retirar_cidade-ref_mbl\" name=\"retirar_cidade-ref_mbl\" value=\"cidade\"><input type=\"hidden\" id=\"retirar_cidade-val_mbl\" name=\"retirar_cidade-val_mbl\" value=\"5406\"><input type=\"hidden\" name=\"aero_retirada_mbl\" id=\"aero_retirada_mbl\" value=\"\"><input type=\"hidden\" name=\"sel_bairro_mbl\" id=\"sel_bairro_mbl\" value=\"\"></div><div class=\"row\"><input class=\"mbl_devolver-outra_check\" type=\"checkbox\" value=\"1\" name=\"devolver-outra\" id=\"devolver-outra\" onclick=\"mbl_check_outro_local(this)\"><span class=\"mbl_check_box\">Devolver em lugar diferente?</span></div><div class=\"mbl_outro_local hide\"><div class=\"row \" style=\"margin-top: -25px; margin-bottom: 15px;\"><div class=\"mbl_escolha_local_dif\">Local diferente: </div><input type=\"text\" name=\"mbl_retirar_cidade_outra\" id=\"mbl_retirar_cidade_outra\" class=\"autocomplete-cidade displayMod mbl_retirar_cidade_outra\" value=\"\" onclick=\"if(this.value==\'Digite a cidade\'){this.value=\'\'}\"onblur=\"if(this.value==\'\'){this.value=\'Digite a cidade\'}\" placeholder=\"Digite a cidade, bairro ou aeroporto\"></div></div><div class=\"row\"><span class=\"mbl_escolha\" style=\"margin-top: -10px; display: block;\">Escolha dia e hora para retirar o carro</span></div><div class=\"row\"><div class=\"small-12 columns\" style=\"display: inline-flex; padding-left: 0px; padding-right: 0px;\"><input type=\"text\" name=\"mbl_dataRetirada\" id=\"mbl_dataRetirada\" class=\"mbl_entrarDatePicker dataRetirada\" value=\"\"><span class=\"sprite_lp_set sprite_lp_set_setas\"></span><select name=\"horaRetirada_mbl\" id=\"horaRetirada_mbl\" style=\"padding-top: 0px; padding-bottom: 0px;\" class=\"mbl_retirada2\"><option value=\"00:00\">00:00</option><option value=\"00:30\">00:30</option><option value=\"01:00\">01:00</option><option value=\"01:30\">01:30</option><option value=\"02:00\">02:00</option><option value=\"02:30\">02:30</option><option value=\"03:00\">03:00</option><option value=\"03:30\">03:30</option><option value=\"04:00\">04:00</option><option value=\"04:30\">04:30</option><option value=\"05:00\">05:00</option><option value=\"05:30\">05:30</option><option value=\"06:00\">06:00</option><option value=\"06:30\">06:30</option><option value=\"07:00\">07:00</option><option value=\"07:30\">07:30</option><option value=\"08:00\">08:00</option><option value=\"08:30\">08:30</option><option value=\"09:00\">09:00</option><option value=\"09:30\">09:30</option><option value=\"10:00\">10:00</option><option value=\"10:30\">10:30</option><option value=\"11:00\">11:00</option><option value=\"11:30\">11:30</option><option value=\"12:00\" selected=\"\">12:00</option><option value=\"12:30\">12:30</option><option value=\"13:00\">13:00</option><option value=\"13:30\">13:30</option><option value=\"14:00\">14:00</option><option value=\"14:30\">14:30</option><option value=\"15:00\">15:00</option><option value=\"15:30\">15:30</option><option value=\"16:00\">16:00</option><option value=\"16:30\">16:30</option><option value=\"17:00\">17:00</option><option value=\"17:30\">17:30</option><option value=\"18:00\">18:00</option><option value=\"18:30\">18:30</option><option value=\"19:00\">19:00</option><option value=\"19:30\">19:30</option><option value=\"20:00\">20:00</option><option value=\"20:30\">20:30</option><option value=\"21:00\">21:00</option><option value=\"21:30\">21:30</option><option value=\"22:00\">22:00</option><option value=\"22:30\">22:30</option><option value=\"23:00\">23:00</option><option value=\"23:30\">23:30</option></select></div></div><div class=\"row\"><div class=\"mbl_escolha\" style=\"margin-top: -12px;\">Escolha dia e hora para devolver o carro</div><div class=\"small-12 columns\" style=\"display: inline-flex; padding-left: 0px; padding-right: 0px;\"><input type=\"text\" name=\"mbl_dataDevolucao\" id=\"mbl_dataDevolucao\" class=\"mbl_entrarDatePicker dataRetirada\" value=\"\"><span class=\"sprite_lp_set sprite_lp_set_setas\"></span><select name=\"horaDevolucao_mbl\" id=\"horaDevolucao_mbl\" style=\"padding-top: 0px; padding-bottom: 0px;\" class=\"mbl_retirada2\"><option value=\"00:00\">00:00</option><option value=\"00:30\">00:30</option><option value=\"01:00\">01:00</option><option value=\"01:30\">01:30</option><option value=\"02:00\">02:00</option><option value=\"02:30\">02:30</option><option value=\"03:00\">03:00</option><option value=\"03:30\">03:30</option><option value=\"04:00\">04:00</option><option value=\"04:30\">04:30</option><option value=\"05:00\">05:00</option><option value=\"05:30\">05:30</option><option value=\"06:00\">06:00</option><option value=\"06:30\">06:30</option><option value=\"07:00\">07:00</option><option value=\"07:30\">07:30</option><option value=\"08:00\">08:00</option><option value=\"08:30\">08:30</option><option value=\"09:00\">09:00</option><option value=\"09:30\">09:30</option><option value=\"10:00\">10:00</option><option value=\"10:30\">10:30</option><option value=\"11:00\">11:00</option><option value=\"11:30\">11:30</option><option value=\"12:00\" selected=\"\">12:00</option><option value=\"12:30\">12:30</option><option value=\"13:00\">13:00</option><option value=\"13:30\">13:30</option><option value=\"14:00\">14:00</option><option value=\"14:30\">14:30</option><option value=\"15:00\">15:00</option><option value=\"15:30\">15:30</option><option value=\"16:00\">16:00</option><option value=\"16:30\">16:30</option><option value=\"17:00\">17:00</option><option value=\"17:30\">17:30</option><option value=\"18:00\">18:00</option><option value=\"18:30\">18:30</option><option value=\"19:00\">19:00</option><option value=\"19:30\">19:30</option><option value=\"20:00\">20:00</option><option value=\"20:30\">20:30</option><option value=\"21:00\">21:00</option><option value=\"21:30\">21:30</option><option value=\"22:00\">22:00</option><option value=\"22:30\">22:30</option><option value=\"23:00\">23:00</option><option value=\"23:30\">23:30</option></select></div></div><div class=\"row\"><button type=\"submit\" class=\"mbl_btn-pesquisa_20\" style=\"font-weight:bold; padding-top: 10px;\"> <span class=\"mbl_tamanho_nome_botao_pesquisa\"> Pesquisar os melhores preços </span> </button></div><div class=\"row\"><span class=\"mlb_reserve\">Reserve também pelo telefone:</span></div><div class=\"row\"><div class=\"small-12 large-12 columns\"><div class=\"row collapse\" style=\"text-align: center;\"><div class=\"small-12 columns\" style=\"display: inline-block; padding-left: 0px; padding-right: 0px;\"><img src=\"//www.carroaluguel.com/images/carroaluguel/telefone_amarelo.png\" style=\"display: inline-block; height: 20px; width: 20px; margin-top: -20px; margin-right: 14px;\"><a href=\"tel:40620633\" class=\"mbl_telefone\">4062-0633</a></div></div></div></div></div></div><div class=\"small-4 columns hide-for-small hide-for-medium\"><div class=\"texto_local_retirada\" style=\"font-size: 15.28px;\"> Local de retirada:</div><input type=\"text\" name=\"retirar_cidade\" id=\"retirar_cidade\" class=\"autocomplete-cidade\" value=\"Recife-PE\" readonly><div class=\"outro_local hide\"><div class=\"texto_local_retirada_devolucao\" style=\"font-size: 15.28px;\">Local diferente: </div><input type=\"text\" name=\"cidade_devolucao\" id=\"cidade_devolucao\" class=\"autocomplete-cidade displayMod arruma_style\" value=\"\"></div><label class=\"devolver-outra\"><input class=\"devolver-outra_check\" type=\"checkbox\" value=\"1\" name=\"devolver-outra\" id=\"devolver-outra\" onclick=\"check_outro_local(this)\"> <label class=\"texto_check_box\">Devolver em um lugar diferente?</label></label></div><div class=\"small-5 columns hide-for-small hide-for-medium\"><input type=\"button\" name=\"limpa_texto\" id=\"limpa_texto\" class=\" hide-for-small hide-for-medium botao_limpador\" onclick=\"limpador_texto_cidade()\"><div class=\"row colapsse\"><div class=\"small-6 large-6 medium-6 columns hide-for-small hide-for-medium\" style=\"margin-top: 3px; margin-left: -5px;\"><div class=\"texto_local_dia_hor_retirada\"> Dia e horário de retirada</div><input type=\"text\" name=\"dataRetirada\" id=\"dataRetirada\" class=\"entrarDatePicker dataRetirada\" value=\"\"\"><select name=\"horaRetirada\" id=\"horaRetirada\" class=\"retirada2\"><option value=\"00:00\">00:00</option><option value=\"00:30\">00:30</option><option value=\"01:00\">01:00</option><option value=\"01:30\">01:30</option><option value=\"02:00\">02:00</option><option value=\"02:30\">02:30</option><option value=\"03:00\">03:00</option><option value=\"03:30\">03:30</option><option value=\"04:00\">04:00</option><option value=\"04:30\">04:30</option><option value=\"05:00\">05:00</option><option value=\"05:30\">05:30</option><option value=\"06:00\">06:00</option><option value=\"06:30\">06:30</option><option value=\"07:00\">07:00</option><option value=\"07:30\">07:30</option><option value=\"08:00\">08:00</option><option value=\"08:30\">08:30</option><option value=\"09:00\">09:00</option><option value=\"09:30\">09:30</option><option value=\"10:00\">10:00</option><option value=\"10:30\">10:30</option><option value=\"11:00\">11:00</option><option value=\"11:30\">11:30</option><option value=\"12:00\" selected=\"\">12:00</option><option value=\"12:30\">12:30</option><option value=\"13:00\">13:00</option><option value=\"13:30\">13:30</option><option value=\"14:00\">14:00</option><option value=\"14:30\">14:30</option><option value=\"15:00\">15:00</option><option value=\"15:30\">15:30</option><option value=\"16:00\">16:00</option><option value=\"16:30\">16:30</option><option value=\"17:00\">17:00</option><option value=\"17:30\">17:30</option><option value=\"18:00\">18:00</option><option value=\"18:30\">18:30</option><option value=\"19:00\">19:00</option><option value=\"19:30\">19:30</option><option value=\"20:00\">20:00</option><option value=\"20:30\">20:30</option><option value=\"21:00\">21:00</option><option value=\"21:30\">21:30</option><option value=\"22:00\">22:00</option><option value=\"22:30\">22:30</option><option value=\"23:00\">23:00</option><option value=\"23:30\">23:30</option></select></div><div class=\"small-6 large-6 medium-6 columns hide-for-small hide-for-medium\" style=\"margin-top: -60px;\"><div class=\"texto_local_dia_hor_retirada\"> Dia e horário de devolução</div><input type=\"text\" name=\"dataDevolucao\" id=\"dataDevolucao\" class=\"entrarDatePicker dataRetirada\" value=\"\"><select name=\"horaDevolucao\" id=\"horaDevolucao\" class=\"retirada2\"><option value=\"00:00\">00:00</option><option value=\"00:30\">00:30</option><option value=\"01:00\">01:00</option><option value=\"01:30\">01:30</option><option value=\"02:00\">02:00</option><option value=\"02:30\">02:30</option><option value=\"03:00\">03:00</option><option value=\"03:30\">03:30</option><option value=\"04:00\">04:00</option><option value=\"04:30\">04:30</option><option value=\"05:00\">05:00</option><option value=\"05:30\">05:30</option><option value=\"06:00\">06:00</option><option value=\"06:30\">06:30</option><option value=\"07:00\">07:00</option><option value=\"07:30\">07:30</option><option value=\"08:00\">08:00</option><option value=\"08:30\">08:30</option><option value=\"09:00\">09:00</option><option value=\"09:30\">09:30</option><option value=\"10:00\">10:00</option><option value=\"10:30\">10:30</option><option value=\"11:00\">11:00</option><option value=\"11:30\">11:30</option><option value=\"12:00\" selected=\"\">12:00</option><option value=\"12:30\">12:30</option><option value=\"13:00\">13:00</option><option value=\"13:30\">13:30</option><option value=\"14:00\">14:00</option><option value=\"14:30\">14:30</option><option value=\"15:00\">15:00</option><option value=\"15:30\">15:30</option><option value=\"16:00\">16:00</option><option value=\"16:30\">16:30</option><option value=\"17:00\">17:00</option><option value=\"17:30\">17:30</option><option value=\"18:00\">18:00</option><option value=\"18:30\">18:30</option><option value=\"19:00\">19:00</option><option value=\"19:30\">19:30</option><option value=\"20:00\">20:00</option><option value=\"20:30\">20:30</option><option value=\"21:00\">21:00</option><option value=\"21:30\">21:30</option><option value=\"22:00\">22:00</option><option value=\"22:30\">22:30</option><option value=\"23:00\">23:00</option><option value=\"23:30\">23:30</option></select></div></div></div><div class=\"small-3 columns hide-for-small hide-for-medium\"><button type=\"submit\" class=\"btn-pesquisa_20\" style=\"font-weight:bold;\"> <span class=\"tamanho_nome_botao_pesquisa\"> PESQUISAR </span> </button></div></div></div></form><div class=\"small-12 columns\"><div class=\"banner_abaixo_pesquisa hide-for-small hide-for-medium\"> <span class=\"sprite_logo_locadoras sprite_sucesso-rent-a-car\" style=\"display:inline-block;margin: 23px 16px;\" title=\"Sucesso Rent a Car\"></span> </div></div></div></div><div class=\"small-12 columns hide-for-small hide-for-medium\"><div class=\"separador_banner_conteudo\"><h1 class=\"texto_separador\" style=\"font-weight: bold;\">Faça tudo de forma simples, rápida e segura<span class=\"texto_separador_baixo\" style=\"font-weight: normal;\"> Você não usa o cartão no site e não paga nada para alterar ou cancelar sua reserva.</span></h1></div></div><div class=\"show-for-medium-up faixa_passos\"><div class=\"row\"><div class=\"large-12 columns arruma_tablet\" style=\"margin-bottom: 20px;\"><ul><li class=\"passo1_tamanho tablet_passos\"><div class=\"row linha_passos\"><div class=\"medium-5 large-5 medium-offset-1 large-offset-1 columns\"><img src=\"//www.carroaluguel.tur.br/images/carroaluguel/lp-locadoras/imgpassos_pesquise.jpg\" alt=\"Pesquise no CarroAluguel\"></div><div class=\"medium-5 large-5 columns\"><div class=\"passos_block\"><span class=\"title_passos tablet_passos2\"><b>Passo 1</b> - Pesquise o menor preço</span><p>Quem aluga pela CARROALUGUEL <b>paga menos do que quem aluga direto no balcão.</b> O motivo: nós negociamos grandes volumes e por isso <b>garantimos vantagens comerciais exclusivas</b> para nossos clientes.</p></div></div><div class=\"medium-1 large-1 hide-for-small columns\"></div></div></li><li class=\"passo2_tamanho tablet_passos\"><div class=\"row linha_passos\"><div class=\"medium-5 large-5 medium-push-6 columns\"><img src=\"//www.carroaluguel.tur.br/images/carroaluguel/lp-locadoras/imgpassos_reserve.jpg\" alt=\"Reserve no CarroAluguel\"></div><div class=\"medium-5 large-5 medium-offset-1 large-offset-1 medium-pull-5 columns\"><div class=\"passos_block\"><span class=\"title_passos tablet_passos2\"><b>Passo 2</b> - Reserve seu veículo</span><p><b>Receba o voucher da sua locação por email.</b> Se <b>precisar alterar data ou hora</b> da sua locação, sem problemas! Faça pelo site acessando sua conta. Você <b>não pagará absolutamente nada. Nenhuma taxa ou multa.</b></p></div></div><div class=\"medium-1 large-1 hide-for-small columns\"></div></div></li><li class=\"passo3_tamanho tablet_passos\"><div class=\"row linha_passos\"><div class=\"medium-5 large-5 medium-offset-1 large-offset-1 medium-order-1 columns\"><img src=\"//www.carroaluguel.tur.br/images/carroaluguel/lp-locadoras/imgpassos_retire.jpg\" alt=\"Retire seu veículo na locadora\"></div><div class=\"medium-5 large-5 medium-order-2 columns\"><div class=\"passos_block\"><span class=\"title_passos tablet_passos2\"><b>Passo 3</b> - Retire seu veículo</span><p>A locadora já <b>estará ciente da sua reserva.</b> Tudo o que você precisa fazer para retirar o carro é <b>apresentar o voucher que recebeu por e-mail e o seu cartão de crédito</b> na loja. Fácil, não?</p></div></div><div class=\"medium-1 large-1 hide-for-small columns\"></div></div></li></ul></div></div></div><div class=\"large-12 columns hide-for-medium\"><div class=\"show-for-medium-up faixa_maior_buscador\"><div class=\"large-12 columns\" style=\"margin-top: -26px;\"><div class=\"large-7 small-12 columns\" style=\"padding-right: 65px; padding-left: 222px;\"><span class=\"seta_voucher hide-for-medium-only\" style=\"margin-left: 80px; margin-top: 286px;\"></span><h2 style=\"font-size: 2.2em; color: #005a9f; margin-bottom: 25px; font-weight: bold; line-height: 34px;\">Somos o maior buscador de preços para aluguel de carros no Brasil</h2><p>Quando você aluga um carro pela CARROALUGUEL usa a nossa tecnologia para pesquisar os preços das maiores locadoras do mundo: são mais de 80 empresas pesquisadas. Pesquise, escolha a melhor oferta e faça sua locação, tudo pelo nosso site.</p><p>Assim que concluir sua locação você receberá por email, na forma de um Voucher, todas as informações necessárias para retirar o seu carro na locadora escolhida. Apresente o Voucher na locadora junto com seus documentos.</p></div><div class=\"large-5 small-12 columns\"><img src=\"//www.carroaluguel.tur.br/images/carroaluguel/lp-locadoras/maior_buscador.png\" alt=\"Voucher de confirmação de reserva\" title=\"Voucher de confirmação de reserva\" style=\"display:block;\"></div></div></div></div><div class=\"large-12 columns hide-for-small hide-for-medium\" style=\"width: 1200px; margin-left: -100px; margin-top: -26px;\"><div class=\"large-12 columns\"><h2 style=\"font-size:2.2em; color:#565656; text-align: center;font-weight:bold; margin-bottom: 20px; line-height: 38px;\">Requisitos necessários para alugar Carro na Locadora Sucesso Recife loja Imbiribeira.</h2></div><div class=\"large-6 columns\"><ul class=\"requisitos-carroaluguel\" style=\"margin-right: 20px;\"><li><span>Ter 21 anos completos;</span></li><li><span>Rg e CPF originais (estrangeiros: passaporte original);</span></li><li><span>Portar cartão de crédito de sua titularidade, dentro da validade, com limite disponível para débito da caução(*) ou o valor total da locação (o que for maior);</span></li><li><span>Atenção: Cartões aceitos na </span><div style=\"display:block;margin: 10px 0;\"><span class=\"sprite_cc mbl_sprite_cc_visa\"></span><span class=\"sprite_cc mbl_sprite_cc_master\"></span><span class=\"sprite_cc mbl_sprite_cc_american\"></span><span class=\"sprite_cc mbl_sprite_cc_hiper\"></span><span class=\"sprite_cc mbl_sprite_cc_dinners\"></span></div></li></ul></div><div class=\"large-6 columns\"><ul class=\"requisitos-carroaluguel\"><li><span>Apresentar carteira nacional de habilitação (CNH) original e válida, expedida há no mínimo 2 anos, estrangeiros podem apresentar carteira de habilitação emitida no país de origem (ideal que seja acompanhada de uma carteira internacional de habilitação);</span></li><li><span>Importante: CNH vencida, mas ainda dentro dos 30 dias permitidos pelos órgãos de trânsito não é aceita pelas locadoras de automóveis;</span></li><li><span>O responsável pela locação não pode ter restrição financeira no CPF;</span></li><li><span>Desejável que o cliente porte um comprovante de endereço original.</span></li></ul></div><div class=\"large-12 columns\"><div class=\"caucao_desc\" style=\"margin-top: -10px; padding-top: 10px; padding-bottom: 2px;\"><p style=\"text-decoration: underline\">*O que é a caução?</p><p>Para alugar um carro é preciso autorizar o valor de uma caução no seu cartão de crédito. Ela serve para preservar tanto o serviço contratado quanto o próprio cliente, que tem o direito de estornar o valor da caução após a entrega do produto ou serviço sem danos. Lembre-se, não é possível realizar o serviço de locação caso a garantia em cartão de crédito não seja deixada na loja onde se retira o carro.</p></div></div></div><div class=\"large-12 columns mbl_poemBaner2 hide-for-large-up hide-for-medium\" style=\"background-color: #fcfbdf; margin-top: -7px; height: 76px;\"><div class=\"row\" style=\"margin-left: 2%;\"><div class=\"small-6 columns\"><span class=\"tick_verde_mbl\"></span><span class=\"mbl_nomes_tick\">Sem taxa de reserva</span></div><div class=\"small-6 columns\"><span class=\"tick_verde_mbl\"></span><span class=\"mbl_nomes_tick\">Pague só na retirada</span></div></div><div class=\"row\" style=\"margin-left: 2%;\"><div class=\"small-6 columns\"><span class=\"tick_verde_mbl\"></span><span class=\"mbl_nomes_tick\">Proteção parcial inclusa</span></div><div class=\"small-6 columns\"><span class=\"tick_verde_mbl\"></span><span class=\"mbl_nomes_tick\">Preços sempre finais</span></div></div></div><div class=\"small-12 columns mbl_poemBaner3 hide-for-large-up hide-for-medium\" style=\"padding-left: 6px;  padding-right: 6px; margin-top: 10px;\"><div class=\"row\" style=\"margin: 5px 0\"><div class=\"small-4 columns\"><img src=\"//www.carroaluguel.tur.br/images/carroaluguel/lp-locadoras/mob-icon-1.png\" class=\"img_vantagens\"></div><div class=\"small-8 columns\" style=\"margin: 0;padding: 0; margin-top: -10px;\"><span class=\"mob_vantagens_title\">Mais barato que no balcão</span><span class=\"mob_vantagens_text\">Negociamos grandes volumes</span></div></div><div class=\"row\" style=\"margin: 5px 0\"><div class=\"small-4 columns\"><img src=\"//www.carroaluguel.tur.br/images/carroaluguel/lp-locadoras/mob-icon-2.png\" class=\"img_vantagens\"></div><div class=\"small-8 columns\" style=\"margin: 0;padding: 0; margin-top: -10px;\"><span class=\"mob_vantagens_title\">Reserve sem cartão de crédito</span><span class=\"mob_vantagens_text\">Informe apenas na retirada do veículo</span></div></div><div class=\"row\" style=\"margin: 5px 0\"><div class=\"small-4 columns\"><img src=\"//www.carroaluguel.tur.br/images/carroaluguel/lp-locadoras/mob-icon-3.png\" class=\"img_vantagens\"></div><div class=\"small-8 columns\" style=\"margin: 0;padding: 0; margin-top: -10px;\"><span class=\"mob_vantagens_title\">Retirada ágil e descomplicada</span><span class=\"mob_vantagens_text\">Basta apresentar nosso voucher</span></div></div></div><div class=\"large-12 columns fundo_comentarios hide-for-small hide-for-medium entra_orbit_1\" style=\"width: 1592px; margin-left: -301px; margin-bottom: 18px; height: 220px;\"><div class=\"large-12 columns\"><h2 class=\"comentarios_title\">Mais de 170.000 clientes satisfeitos desde 2008</h2></div><ul class=\"orbit-container\" data-orbit data-options=\"bullets:false;timer:false;\" style=\"height: 213px;\"><li><div class=\"large-12 columns comentarios_alinhador\"><div class=\"comentarios_orbit comentarios_primeiro\">\"Só tenho palavras de agradecimento, fiquei muito tranquila com a locação.\"<br><span class=\"nome_comentarios\">Ana Amélia - 21/03/2016</span></div><div class=\"comentarios_orbit\">\"Gostei muito do trabalho oferecido para uma locaçao rápida e de confiança.\"<br><span class=\"nome_comentarios\">João Paulo - 13/05/2016</span></div><div class=\"comentarios_orbit\">\"Tive muita satisfação e agilidade na minha locação, recomento a todos.\"<br><span class=\"nome_comentarios\">Rodrigo Yamada - 01/07/2016</span></div></div></li><li><div class=\"large-12 columns comentarios_alinhador\"><div class=\"comentarios_orbit comentarios_primeiro\">\"A locação aconteceu muito bem e muito rápida, me surprieendi.\"<br><span class=\"nome_comentarios\">Joaquina Sampaio - 19/07/2016</span></div><div class=\"comentarios_orbit\">\"O serviço oferecido pela carroaluguel.com é de uma ótima qualidade.\"<br><span class=\"nome_comentarios\">Larissa Schmidtz - 03/09/2016</span></div></div></li></ul></div><div class=\"large-12 columns mbl_tirarBaner4 hide-for-large-up\"><div class=\"row\"><span class=\"mbl_titulo_requisitos\">Requisitos necessários para alugar carro na locadora Sucesso Recife loja Imbiribeira.</span></div><div class=\"row\"><div class=\"mbl_li\"><span style=\" color: black; font-size: 12px;\" class=\"mbl_text\">Ter 21 anos completos;</span></div><div class=\"mbl_li\"><span style=\" color: black; font-size: 12px;\" class=\"mbl_text\">RG e CPF originais (estrangeiros: passaporte original);</span></div><div class=\"mbl_li\"><span style=\" color: black; font-size: 12px;\" class=\"mbl_text\">Portar cartão de crédito de sua titularidade, dentro da validade, com limite disponível para débito da caução(*) ou o valor total da locação (o que for maior);</span></div><div class=\"mbl_li\"><span style=\" color: black; font-size: 12px;\" class=\"mbl_text\">Apresentar carteira nacional de habilitação (CNH) original e válida, expedida há no mínimo 2 anos, estrangeiros podem apresentar carteira de habilitação emitida no país de origem (ideal que seja acompanhada de uma carteira internacional de habilitação);</span></div><div class=\"mbl_li\"><span style=\" color: black; font-size: 12px;\" class=\"mbl_text\">Importante: CNH vencida, mas ainda dentro dos 30 dias permitidos pelos órgãos de trânsito não é aceita pelas locadoras de automóveis;</span></div><div class=\"mbl_li\"><span style=\" color: black; font-size: 12px;\" class=\"mbl_text\">O responsável pela locação não pode ter restrição financeira no CPF;</span></div><div class=\"mbl_li\"><span style=\" color: black; font-size: 12px;\" class=\"mbl_text\">Desejável que o cliente porte um comprovante de endereço original.</span></div></div></div><div class=\"large-12 columns mbl_tirarBaner5 hide-for-large-up\"><div class=\"row\"><span class=\"mbl_titulo_requisitos mbl_titulo_azul\" style=\"width: 100%; margin-top: -5px;\">Tarifas e frota </span></div><div class=\"row\"><div class=\"large-12 columns entra_orbit_mbl\" style=\"padding-left: 7px; padding-right: 7px;\"><ul class=\"example-orbit-content mbl_arruma_altura\" data-orbit data-options=\"bullets:false;timer:false;next_on_click: false\" style=\"background-color: #f3f3f3;border-radius: 7px;\"><li data-orbit-slide=\"headline-1\"><div><h2 class=\"mbl_titulo_carro\">Básico sem AR</h2><h3><ul class=\"example-orbit-content arruma_tamanho2_mbl\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center>Novo Uno<img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/novouno.png\" alt=\"Novo Uno, Up ou similar\" title=\"Novo Uno, Up ou similar\" style=\"max-height:190px\"/></center></li><li data-orbit-slide=\"headline-2\"><center>Up<img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/up.png\" alt=\"Novo Uno, Up ou similar\" title=\"Novo Uno, Up ou similar\" style=\"max-height:190px\"/></center></li></ul></h3></div><div class=\"mbl_final_orbit\" style=\"letter-spacing: -1px;\"><span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_cambio_mbl tooltip\" title=\"Cambio Manual\" style=\"display: inline-block;\">                                <span class=\"mbl_arruma_letras\" style=\"margin-left:  -1px !important;\">Manu</span></span>                            </span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_motor_mbl tooltip\" title=\"Motor\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">1.0</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_portas_mbl tooltip\" title=\"Quantidade de portas\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: 6px;\">4</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_malas_mbl tooltip\" title=\"Bagagens\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">2|1</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_pessoas_mbl tooltip\" title=\"Quantidade de pessoas\" style=\"display: inline-block;\"><span class=mbl_arruma_letras style=\"margin-left: 6px;\">5</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_air_mbl tooltip\" title=\"Airbag\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -5px;\">Airbag</span></span></div><hr class=\"mbl_hr_container\"><div class=\"row mbl_precos_container2\"><div class=\"small-12 columns arruma_br_mbl\"><span>Valor da Caução:  <span style=\"color: black; font-size: 13px;\">R$ 700,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</span></span></div></div><div class=\"row mbl_precos_container4\"><div class=\"small-12 columns\"><button type=\"submit\" class=\"btn-pesquisa modal_reserva_mbl\" style=\"width: 86%; margin-left: 24px; color: white;\">Reservar Agora ></button></div></div></li><li data-orbit-slide=\"headline-1\"><div><h2 class=\"mbl_titulo_carro\">Básico + AR + DH</h2><h3><ul class=\"example-orbit-content arruma_tamanho2_mbl\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center>Novo Uno<img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/novouno.png\" alt=\"Novo Uno, Up ou similar\" title=\"Novo Uno, Up ou similar\" style=\"max-height:190px\"/></center></li><li data-orbit-slide=\"headline-2\"><center>Up<img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/up.png\" alt=\"Novo Uno, Up ou similar\" title=\"Novo Uno, Up ou similar\" style=\"max-height:190px\"/></center></li></ul></h3></div><div class=\"mbl_final_orbit\" style=\"letter-spacing: -1px;\"><span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_ar_mbl tooltip\" title=\"Ar condicionado\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">AR</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_dh_mbl tooltip\" title=\"Direção Hidraulica\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">DH</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_cambio_mbl tooltip\" title=\"Cambio Manual\" style=\"display: inline-block;\">                                <span class=\"mbl_arruma_letras\" style=\"margin-left:  -1px !important;\">Manu</span></span>                            </span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_motor_mbl tooltip\" title=\"Motor\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">1.0</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_som_mbl tooltip\" title=\"Som\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -1px;\">Som</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_portas_mbl tooltip\" title=\"Quantidade de portas\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: 6px;\">4</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_malas_mbl tooltip\" title=\"Bagagens\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">2|1</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_pessoas_mbl tooltip\" title=\"Quantidade de pessoas\" style=\"display: inline-block;\"><span class=mbl_arruma_letras style=\"margin-left: 6px;\">5</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_air_mbl tooltip\" title=\"Airbag\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -5px;\">Airbag</span></span></div><hr class=\"mbl_hr_container\"><div class=\"row mbl_precos_container2\"><div class=\"small-12 columns arruma_br_mbl\"><span>Valor da Caução:  <span style=\"color: black; font-size: 13px;\">R$ 700,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</span></span></div></div><div class=\"row mbl_precos_container4\"><div class=\"small-12 columns\"><button type=\"submit\" class=\"btn-pesquisa modal_reserva_mbl\" style=\"width: 86%; margin-left: 24px; color: white;\">Reservar Agora ></button></div></div></li><li data-orbit-slide=\"headline-1\"><div><h2 class=\"mbl_titulo_carro\">Básico + AR + DH</h2><h3><ul class=\"example-orbit-content arruma_tamanho2_mbl\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center>Onix<img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/onix.png\" alt=\"Onix, Fox ou similar\" title=\"Onix, Fox ou similar\" style=\"max-height:190px\"/></center></li><li data-orbit-slide=\"headline-2\"><center>Fox<img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/fox.png\" alt=\"Onix, Fox ou similar\" title=\"Onix, Fox ou similar\" style=\"max-height:190px\"/></center></li></ul></h3></div><div class=\"mbl_final_orbit\" style=\"letter-spacing: -1px;\"><span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_ar_mbl tooltip\" title=\"Ar condicionado\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">AR</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_dh_mbl tooltip\" title=\"Direção Hidraulica\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">DH</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_cambio_mbl tooltip\" title=\"Cambio Manual\" style=\"display: inline-block;\">                                <span class=\"mbl_arruma_letras\" style=\"margin-left:  -1px !important;\">Manu</span></span>                            </span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_motor_mbl tooltip\" title=\"Motor\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">1.0</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_som_mbl tooltip\" title=\"Som\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -1px;\">Som</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_portas_mbl tooltip\" title=\"Quantidade de portas\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: 6px;\">4</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_malas_mbl tooltip\" title=\"Bagagens\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">1|1</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_pessoas_mbl tooltip\" title=\"Quantidade de pessoas\" style=\"display: inline-block;\"><span class=mbl_arruma_letras style=\"margin-left: 6px;\">5</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_air_mbl tooltip\" title=\"Airbag\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -5px;\">Airbag</span></span></div><hr class=\"mbl_hr_container\"><div class=\"row mbl_precos_container2\"><div class=\"small-12 columns arruma_br_mbl\"><span>Valor da Caução:  <span style=\"color: black; font-size: 13px;\">R$ 700,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</span></span></div></div><div class=\"row mbl_precos_container4\"><div class=\"small-12 columns\"><button type=\"submit\" class=\"btn-pesquisa modal_reserva_mbl\" style=\"width: 86%; margin-left: 24px; color: white;\">Reservar Agora ></button></div></div></li><li data-orbit-slide=\"headline-1\"><div><h2 class=\"mbl_titulo_carro\">Compacto</h2><h3><ul class=\"example-orbit-content arruma_tamanho2_mbl\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center>Fox<img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/fox.png\" alt=\"Fox, Sandero ou similar\" title=\"Fox, Sandero ou similar\" style=\"max-height:190px\"/></center></li><li data-orbit-slide=\"headline-2\"><center>Sandero<img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/sandero.png\" alt=\"Fox, Sandero ou similar\" title=\"Fox, Sandero ou similar\" style=\"max-height:190px\"/></center></li></ul></h3></div><div class=\"mbl_final_orbit\" style=\"letter-spacing: -1px;\"><span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_ar_mbl tooltip\" title=\"Ar condicionado\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">AR</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_dh_mbl tooltip\" title=\"Direção Hidraulica\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">DH</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_cambio_mbl tooltip\" title=\"Cambio Manual\" style=\"display: inline-block;\">                                <span class=\"mbl_arruma_letras\" style=\"margin-left:  -1px !important;\">Manu</span></span>                            </span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_motor_mbl tooltip\" title=\"Motor\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">1.6</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_som_mbl tooltip\" title=\"Som\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -1px;\">Som</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_portas_mbl tooltip\" title=\"Quantidade de portas\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: 6px;\">4</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_malas_mbl tooltip\" title=\"Bagagens\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">2|2</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_pessoas_mbl tooltip\" title=\"Quantidade de pessoas\" style=\"display: inline-block;\"><span class=mbl_arruma_letras style=\"margin-left: 6px;\">5</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_air_mbl tooltip\" title=\"Airbag\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -5px;\">Airbag</span></span></div><hr class=\"mbl_hr_container\"><div class=\"row mbl_precos_container2\"><div class=\"small-12 columns arruma_br_mbl\"><span>Valor da Caução:  <span style=\"color: black; font-size: 13px;\">R$ 1.000,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</span></span></div></div><div class=\"row mbl_precos_container4\"><div class=\"small-12 columns\"><button type=\"submit\" class=\"btn-pesquisa modal_reserva_mbl\" style=\"width: 86%; margin-left: 24px; color: white;\">Reservar Agora ></button></div></div></li><li data-orbit-slide=\"headline-1\"><div><h2 class=\"mbl_titulo_carro\">Sedan Compacto</h2><h3><ul class=\"example-orbit-content arruma_tamanho2_mbl\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center>Voyage<img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/voyage.png\" alt=\"Voyage, Cobalt ou similar\" title=\"Voyage, Cobalt ou similar\" style=\"max-height:190px\"/></center></li><li data-orbit-slide=\"headline-2\"><center>Cobalt<img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/cobalt.png\" alt=\"Voyage, Cobalt ou similar\" title=\"Voyage, Cobalt ou similar\" style=\"max-height:190px\"/></center></li></ul></h3></div><div class=\"mbl_final_orbit\" style=\"letter-spacing: -1px;\"><span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_ar_mbl tooltip\" title=\"Ar condicionado\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">AR</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_dh_mbl tooltip\" title=\"Direção Hidraulica\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">DH</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_cambio_mbl tooltip\" title=\"Cambio Manual\" style=\"display: inline-block;\">                                <span class=\"mbl_arruma_letras\" style=\"margin-left:  -1px !important;\">Manu</span></span>                            </span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_motor_mbl tooltip\" title=\"Motor\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">1.6</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_som_mbl tooltip\" title=\"Som\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -1px;\">Som</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_portas_mbl tooltip\" title=\"Quantidade de portas\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: 6px;\">4</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_malas_mbl tooltip\" title=\"Bagagens\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">2|2</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_pessoas_mbl tooltip\" title=\"Quantidade de pessoas\" style=\"display: inline-block;\"><span class=mbl_arruma_letras style=\"margin-left: 6px;\">5</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_air_mbl tooltip\" title=\"Airbag\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -5px;\">Airbag</span></span></div><hr class=\"mbl_hr_container\"><div class=\"row mbl_precos_container2\"><div class=\"small-12 columns arruma_br_mbl\"><span>Valor da Caução:  <span style=\"color: black; font-size: 13px;\">R$ 1.000,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</span></span></div></div><div class=\"row mbl_precos_container4\"><div class=\"small-12 columns\"><button type=\"submit\" class=\"btn-pesquisa modal_reserva_mbl\" style=\"width: 86%; margin-left: 24px; color: white;\">Reservar Agora ></button></div></div></li><li data-orbit-slide=\"headline-1\"><div><h2 class=\"mbl_titulo_carro\">Van Média</h2><h3><ul class=\"example-orbit-content arruma_tamanho2_mbl\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center>Doblò <img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/doblo.png\" alt=\"Doblò  ou similar\" title=\"Doblò  ou similar\" style=\"max-height:190px\"/></center></li></ul></h3></div><div class=\"mbl_final_orbit\" style=\"letter-spacing: -1px;\"><span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_ar_mbl tooltip\" title=\"Ar condicionado\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">AR</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_dh_mbl tooltip\" title=\"Direção Hidraulica\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">DH</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_cambio_mbl tooltip\" title=\"Cambio Manual\" style=\"display: inline-block;\">                                <span class=\"mbl_arruma_letras\" style=\"margin-left:  -1px !important;\">Manu</span></span>                            </span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_motor_mbl tooltip\" title=\"Motor\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">1.4</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_som_mbl tooltip\" title=\"Som\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -1px;\">Som</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_portas_mbl tooltip\" title=\"Quantidade de portas\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: 6px;\">4</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_malas_mbl tooltip\" title=\"Bagagens\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">2|3</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_pessoas_mbl tooltip\" title=\"Quantidade de pessoas\" style=\"display: inline-block;\"><span class=mbl_arruma_letras style=\"margin-left: 6px;\">7</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_air_mbl tooltip\" title=\"Airbag\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -5px;\">Airbag</span></span></div><hr class=\"mbl_hr_container\"><div class=\"row mbl_precos_container2\"><div class=\"small-12 columns arruma_br_mbl\"><span>Valor da Caução:  <span style=\"color: black; font-size: 13px;\">R$ 1.500,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</span></span></div></div><div class=\"row mbl_precos_container4\"><div class=\"small-12 columns\"><button type=\"submit\" class=\"btn-pesquisa modal_reserva_mbl\" style=\"width: 86%; margin-left: 24px; color: white;\">Reservar Agora ></button></div></div></li><li data-orbit-slide=\"headline-1\"><div><h2 class=\"mbl_titulo_carro\">Van Compacta</h2><h3><ul class=\"example-orbit-content arruma_tamanho2_mbl\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center>Spin<img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/spin.png\" alt=\"Spin ou similar\" title=\"Spin ou similar\" style=\"max-height:190px\"/></center></li></ul></h3></div><div class=\"mbl_final_orbit\" style=\"letter-spacing: -1px;\"><span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_ar_mbl tooltip\" title=\"Ar condicionado\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">AR</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_dh_mbl tooltip\" title=\"Direção Hidraulica\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">DH</span></span>&nbsp;&nbsp;&nbsp;<span  class=\"sprite_caracteristicas_mbl sprite_caracteristicas_cambio_mbl tooltip\" title=\"Cambio Automático\" style=\"display: inline-block;\">                                <span class=\"mbl_arruma_letras\" style=\"margin-left:  -1px !important;\">Auto</span>                            </span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_motor_mbl tooltip\" title=\"Motor\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">1.8</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_som_mbl tooltip\" title=\"Som\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -1px;\">Som</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_portas_mbl tooltip\" title=\"Quantidade de portas\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: 6px;\">4</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_malas_mbl tooltip\" title=\"Bagagens\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">1|1</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_pessoas_mbl tooltip\" title=\"Quantidade de pessoas\" style=\"display: inline-block;\"><span class=mbl_arruma_letras style=\"margin-left: 6px;\">7</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_air_mbl tooltip\" title=\"Airbag\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -5px;\">Airbag</span></span></div><hr class=\"mbl_hr_container\"><div class=\"row mbl_precos_container2\"><div class=\"small-12 columns arruma_br_mbl\"><span>Valor da Caução:  <span style=\"color: black; font-size: 13px;\">R$ 1.500,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</span></span></div></div><div class=\"row mbl_precos_container4\"><div class=\"small-12 columns\"><button type=\"submit\" class=\"btn-pesquisa modal_reserva_mbl\" style=\"width: 86%; margin-left: 24px; color: white;\">Reservar Agora ></button></div></div></li><li data-orbit-slide=\"headline-1\"><div><h2 class=\"mbl_titulo_carro\">Automático</h2><h3><ul class=\"example-orbit-content arruma_tamanho2_mbl\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center>Corolla<img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/corola.png\" alt=\"Corolla, Cruze  ou similar\" title=\"Corolla, Cruze  ou similar\" style=\"max-height:190px\"/></center></li><li data-orbit-slide=\"headline-2\"><center>Cruze <img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/cruze.png\" alt=\"Corolla, Cruze  ou similar\" title=\"Corolla, Cruze  ou similar\" style=\"max-height:190px\"/></center></li></ul></h3></div><div class=\"mbl_final_orbit\" style=\"letter-spacing: -1px;\"><span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_ar_mbl tooltip\" title=\"Ar condicionado\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">AR</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_dh_mbl tooltip\" title=\"Direção Hidraulica\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">DH</span></span>&nbsp;&nbsp;&nbsp;<span  class=\"sprite_caracteristicas_mbl sprite_caracteristicas_cambio_mbl tooltip\" title=\"Cambio Automático\" style=\"display: inline-block;\">                                <span class=\"mbl_arruma_letras\" style=\"margin-left:  -1px !important;\">Auto</span>                            </span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_motor_mbl tooltip\" title=\"Motor\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">2.0</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_som_mbl tooltip\" title=\"Som\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -1px;\">Som</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_portas_mbl tooltip\" title=\"Quantidade de portas\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: 6px;\">4</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_malas_mbl tooltip\" title=\"Bagagens\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">2|2</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_pessoas_mbl tooltip\" title=\"Quantidade de pessoas\" style=\"display: inline-block;\"><span class=mbl_arruma_letras style=\"margin-left: 6px;\">5</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_air_mbl tooltip\" title=\"Airbag\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -5px;\">Airbag</span></span></div><hr class=\"mbl_hr_container\"><div class=\"row mbl_precos_container2\"><div class=\"small-12 columns arruma_br_mbl\"><span>Valor da Caução:  <span style=\"color: black; font-size: 13px;\">R$ 4.000,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</span></span></div></div><div class=\"row mbl_precos_container4\"><div class=\"small-12 columns\"><button type=\"submit\" class=\"btn-pesquisa modal_reserva_mbl\" style=\"width: 86%; margin-left: 24px; color: white;\">Reservar Agora ></button></div></div></li><li data-orbit-slide=\"headline-1\"><div><h2 class=\"mbl_titulo_carro\">SUV Compacta</h2><h3><ul class=\"example-orbit-content arruma_tamanho2_mbl\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center>Duster<img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/duster.png\" alt=\"Duster ou similar\" title=\"Duster ou similar\" style=\"max-height:190px\"/></center></li></ul></h3></div><div class=\"mbl_final_orbit\" style=\"letter-spacing: -1px;\"><span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_ar_mbl tooltip\" title=\"Ar condicionado\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">AR</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_dh_mbl tooltip\" title=\"Direção Hidraulica\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">DH</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_cambio_mbl tooltip\" title=\"Cambio Manual\" style=\"display: inline-block;\">                                <span class=\"mbl_arruma_letras\" style=\"margin-left:  -1px !important;\">Manu</span></span>                            </span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_motor_mbl tooltip\" title=\"Motor\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">1.6</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_som_mbl tooltip\" title=\"Som\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -1px;\">Som</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_portas_mbl tooltip\" title=\"Quantidade de portas\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: 6px;\">4</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_malas_mbl tooltip\" title=\"Bagagens\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\">3|3</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_pessoas_mbl tooltip\" title=\"Quantidade de pessoas\" style=\"display: inline-block;\"><span class=mbl_arruma_letras style=\"margin-left: 6px;\">5</span></span>&nbsp;&nbsp;&nbsp;<span class=\"sprite_caracteristicas_mbl sprite_caracteristicas_air_mbl tooltip\" title=\"Airbag\" style=\"display: inline-block;\"><span class=\"mbl_arruma_letras\" style=\"margin-left: -5px;\">Airbag</span></span></div><hr class=\"mbl_hr_container\"><div class=\"row mbl_precos_container2\"><div class=\"small-12 columns arruma_br_mbl\"><span>Valor da Caução:  <span style=\"color: black; font-size: 13px;\">R$ 1.500,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</span></span></div></div><div class=\"row mbl_precos_container4\"><div class=\"small-12 columns\"><button type=\"submit\" class=\"btn-pesquisa modal_reserva_mbl\" style=\"width: 86%; margin-left: 24px; color: white;\">Reservar Agora ></button></div></div></li></ul></div></div></div><div class=\"large-12 columns mbl_tirarBaner6 hide-for-large-up\"><div class=\"row\"><span class=\"mbl_titulo_requisitos mbl_titulo_azul\" style=\"width: 100%; margin-top: -5px;\">Formas de pagamento </span></div><div class=\"row mbl_protecoes_letras\">A Sucesso Rent a Car aceita pagamentos apenas com cartão de crédito, é possível dividir em até 3 vezes sem juros e a parcela mínima é de R$ 500,00.</div><div class=\"row mbl_forma_pag_bandeiras\">Bandeiras aceitas:<br><span class=\"sprite_cc mbl_sprite_cc_visa\"></span><span class=\"sprite_cc mbl_sprite_cc_master\"></span><span class=\"sprite_cc mbl_sprite_cc_american\"></span><span class=\"sprite_cc mbl_sprite_cc_hiper\"></span><span class=\"sprite_cc mbl_sprite_cc_dinners\"></span></div></div><div class=\"large-12 columns mbl_tirarBaner7 hide-for-large-up\"><div class=\"row\"><span class=\"mbl_titulo_requisitos mbl_titulo_azul\" style=\"width: 100%; margin-top: -5px;\">Proteções </span></div><div class=\"row collapse\"><div class=\"row mbl_forma_pag\"><div id=\"protecoes\" class=\"row inner-accordion\" style=\"display:block\"><div class=\"medium-1 large-1 columns\" style=\"margin-right: 50px; margin-top: 5px; float: right;\"><span class=\"sprite_header_mbl sprite_protecao_mbl\"></span></div><div class=\"medium-12 large-12 columns\" style=\"margin-top: -30px;\"><div class=\"arruma_paragrafo_mbl\"><h3 style=\"margin-bottom: -2px; margin-left: -10px;\">Proteção parcial do carro</h3><span class=\"mbl_fundo_laranja\">Inclusa na diária</span>                                                                    <div class=\"protecao_desc\" style=\"margin-left: -10px; margin-top: 10px;\">Para os grupos <a href=\"javascript:void(0)\" data-tooltip=\"Básico + AR + DH\">B</a>, <a href=\"javascript:void(0)\" data-tooltip=\"Básico + AR + DH\">C</a>, <a href=\"javascript:void(0)\" data-tooltip=\"Compacto\">D</a>, <a href=\"javascript:void(0)\" data-tooltip=\"Sedan Compacto\">E</a>, <a href=\"javascript:void(0)\" data-tooltip=\"Van Compacta\">F</a>, <a href=\"javascript:void(0)\" data-tooltip=\"SUV Compacta\">G</a>, <a href=\"javascript:void(0)\" data-tooltip=\"Van Média\">I</a>, <a href=\"javascript:void(0)\" data-tooltip=\"Automático\">J</a>: <p>Prote&ccedil;&atilde;o ao ve&iacute;culo locado para avarias, colis&otilde;es, roubo, furto, inc&ecirc;ndio e perda total, cabendo ao locat&aacute;rio arcar com a coparticipa&ccedil;&atilde;o estabelecida em contrato de at&eacute; 10% para colis&otilde;es e acidentes e 20% para roubo, inc&ecirc;ndio e perda total, ambos calculados sobre o pre&ccedil;o de tabela vigente do ve&iacute;culo zero quilometro.</p></div></div></div><div class=\"medium-12 large-12 columns mbl_hide_protecoes hide\"><div><div class=\"protecao_desc mbl_hide_protecoes hide\" style=\"font-size: 14px; display: block; margin-left: -10px;\"><span class=\"protecoes_aviso\" style=\"display:block;color:#ff0000;margin: 10px 0;font-weight: bold;\">IMPORTANTE</span>Ficam sob inteira responsabilidade do CLIENTE, (<b>uma vez que os itens a seguir não estão cobertos por quaisquer proteções</b>) os equipamentos e acessórios (faróis, lanternas, espelhos retrovisores internos e externos, rádio, compact disk (CD player), pneus, rodas de ferro ou liga leve, triângulo, chaves de roda, macaco compatível com o peso e carga do veículo, extintor de incêndio, acendedor de cigarros, protetor de cárter, bateria, capotas de fibra, chaves do veículo, estofamentos, calotas, antena, estepe completo com ou sem câmara de ar, jogo de tapetes, para-sol, assentos e forrações danificadas, vidros inclusive danos ao pára-brisa, grades e documentos do veiculo CRLV), não podendo ser substituídos ou inutilizados, a não ser quando expressamente autorizado pela LOCADORA. Nos casos de comprovada imperícia, imprudência, desobediência às leis de trânsito, ou utilização indevida do veículo, e/ou a não entrega do BO (Boletim de Ocorrência) no prazo de 24 horas, representarão perda da cobertura, passando o locatário a arcar com as despesas integrais do dano ao veículo.</div></div><br></div></div><div class=\"row collapse\" style=\"display: block; text-align: center; margin-top: -20px;\"><button type=\"button\" class=\"mbl_botao_protecao\" style=\"width: 86%; margin-left: -44px; color: white;\">Ver mais opções</button><button type=\"button\" class=\"mbl_botao_protecao_hide hide\" style=\"width: 86%; margin-left: -44px; color: white;\">Ver menos opções</button></div></div></div></div><div class=\"large-12 columns mbl_tirarBaner8 hide-for-large-up\"><div class=\"row\"><span class=\"mbl_titulo_requisitos mbl_titulo_azul\" style=\"width: 100%; margin-top: -5px;\">Localização </span><div class=\"row\" style=\"padding-left: 30px;   width: 98%;\"><span class=\"titulo_maps\">Digite seu endereço para traçar rota até a locadora:</span></div><div class=\"row\" style=\" width: 98%; padding: 10px; margin-top: -15px; padding-left: 30px;\"><div class=\"arruma_search_maps\"><input type=\"text\" id=\"txtEnderecoPartida_mbl\" name=\"txtEnderecoPartida_mbl\" class=\"text_maps\" /><input type=\"submit\" id=\"btnEnviar_mbl\" name=\"btnEnviar_mbl\" value=\"\" class=\"search_maps\" /><input type=\"hidden\" id=\"hdnOrigem\" name=\"hdnOrigem\"/><input type=\"hidden\" id=\"hdnDestino\" name=\"hdnDestino\" value=\"Av. Mal. Mascarenhas de Morais, 5855Recife\"/><input type=\"hidden\" id=\"hdnDestinoLatiLong\" name=\"hdnDestinoLatiLong\" value=\"-8.135045 -34.916344\"/></div></div><div class=\"row mostra_origem_dest_mbl hide\" style=\"margin-top: 20px; width: 94%; padding-left: 30px; margin-bottom: 10px;\"><div class=\"origem_dest\"><img src=\"//www.carroaluguel.com/images/carroaluguel/tick_A.png\" style=\"display: block; height: 33px;\"><div class=\"arruma_origem\"><span class=\"texto_origem\">Origem:</span> <span id=\"texto_origem_mbl\"></span></div></img><img src=\"//www.carroaluguel.com/images/carroaluguel/tick_B.png\" style=\"display: block; height: 33px;\"><div class=\"arruma_origem\"><span class=\"texto_origem\">Destino:</span> <span>Av. Mal. Mascarenhas de Morais, 5855Recife</span></div></img></div></div><div id=\"mapa_mbl\"></div></div><div class=\"row entra_mbl_orbit_final\"><div class=\"small-12 columns localizacao_locadoras_mbl\"><ul data-orbit data-options=\"navigation_arrows:false;  bullets:true; timer:false;\"><li data-orbit-slide=\"headline-1\"><div><img class=\"imgs_finais_mbl\" src=\"http://placehold.it/530x250&text=Imagem temporária\"></div></li></ul><div class=\"row\" style=\"font-size: 12px; margin-left: 3px; padding-right: 1px; margin-top: 10px; margin-bottom: 10px;\"><span class=\"titulos_loc\" style=\"margin-top: 20px;\">Av. Mal. Mascarenhas de Morais, 5855</span>  <br><span class=\"titulos_loc\">Bairro:</span> Imbiribeira <br><span class=\"titulos_loc\">Cidade:</span> Recife <br><span class=\"titulos_loc\">Estado:</span> Pernambuco<br><br><span class=\"titulos_loc\">Horários:</span><br>Segunda à sexta-feira das 0h às 23h<br>Sábados das 0h às 23h <br><br><br><span class=\"titulos_loc\">Reserve também pelo nossos telefones:</span><br><a href=\"tel:\"></a></div></div></div></div><div class=\"large-12 columns linha_titulos hide-for-small hide-for-medium\"><span class=\"titulo_tarifas\">Tarifas e frota da Sucesso nesta loja</span></div><div class=\"medium-12 large-12 columns entra_orbit_2 hide-for-medium\"><div id=\"frota\" class=\"row inner-accordion show-for-medium-up\"><ul class=\"orbit-container tamanho_frota_desk\" data-orbit data-options=\"animation:fade;bullets:false;timer:false;next_on_click: false\" style=\"max-height: 600px; height: 488px !important;  margin-bottom: 20px;\"><li data-orbit-slide=\"headline-1\"><div class=\"frota_orbit2\"><div class=\"medium-6 large-6 columns\"><h3 class=\"arruma_imagens_frotaNova\"><ul class=\"example-orbit-content\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center><img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/novouno.png\" alt=\"Novo Uno, Up ou similar\" title=\"Novo Uno, Up ou similar\" style=\"max-height:240px\"/></center></li><li data-orbit-slide=\"headline-2\"><center><img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/up.png\" alt=\"Novo Uno, Up ou similar\" title=\"Novo Uno, Up ou similar\" style=\"max-height:240px\"/></center></li></ul></h3></div><div class=\"medium-6 large-6 columns\"><h3 style=\"margin-bottom: 10px; margin-left: -2px; margin-top: 16px;\">Básico sem AR</h3><h2 class=\"nomes_dos_carros\">Novo Uno, Up ou similar</h2><hr style=\"margin-bottom: 20px !important;\"><div class=\"row\" style=\"margin-top: -10px !important;\"><button type=\"submit\" class=\"buscar_cotacao\" style=\"    margin-top: 13px !important;\">Verifique preços e disponibilidade</button></div></div></div><div class=\"row collapse\" style=\"margin-top: -290px; margin-left: 20px;\"><div class=\"medium-12 large-12 columns\" style=\"text-align: center;\"><div style=\"width: 100%;\"><div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Manual</span>                                    <span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_cambio tooltip\" title=\"Câmbio\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Motor 1.0</span><span class=\"sprite_caracteristicas sprite_caracteristicas_motor arruma_icones_desk tooltip\" title=\"Motor\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\"> 4 portas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_portas arruma_icones_desk tooltip\" title=\"Portas\" ></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">2p. 1g.</span><span class=\"sprite_caracteristicas sprite_caracteristicas_malas arruma_icones_desk tooltip\" title=\"Numero de malas\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">5 pessoas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_pessoas arruma_icones_desk tooltip\" title=\"Passageiros\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">AirBag</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_airbag tooltip\" title=\"Airbag\"></span></div>&nbsp;&nbsp;</div></div></div><div class=\"row\"  style=\"width: 110% !important;  margin-left: 180px; margin-top: 20px;\"><div class=\"medium-8 large-8 columns\" style=\"padding: 0 30px; margin-top: 15px;\"><p class=\"franquia_line\"><span style=\"font-weight: bold;\">Caução:</span> R$ 700,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</p></div><div class=\"medium-4 large-4 columns\" style=\"padding-top: 10px; text-align:right; \"></div></div></li><li data-orbit-slide=\"headline-2\"><div class=\"frota_orbit2\"><div class=\"medium-6 large-6 columns\"><h3 class=\"arruma_imagens_frotaNova\"><ul class=\"example-orbit-content\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center><img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/novouno.png\" alt=\"Novo Uno, Up ou similar\" title=\"Novo Uno, Up ou similar\" style=\"max-height:240px\"/></center></li><li data-orbit-slide=\"headline-2\"><center><img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/up.png\" alt=\"Novo Uno, Up ou similar\" title=\"Novo Uno, Up ou similar\" style=\"max-height:240px\"/></center></li></ul></h3></div><div class=\"medium-6 large-6 columns\"><h3 style=\"margin-bottom: 10px; margin-left: -2px; margin-top: 16px;\">Básico + AR + DH</h3><h2 class=\"nomes_dos_carros\">Novo Uno, Up ou similar</h2><hr style=\"margin-bottom: 20px !important;\"><div class=\"row\" style=\"margin-top: -10px !important;\"><button type=\"submit\" class=\"buscar_cotacao\" style=\"    margin-top: 13px !important;\">Verifique preços e disponibilidade</button></div></div></div><div class=\"row collapse\" style=\"margin-top: -290px; margin-left: 20px;\"><div class=\"medium-12 large-12 columns\" style=\"text-align: center;\"><div style=\"width: 100%;\"><div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Ar</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_ar tooltip\" title=\"Ar condicionado\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">DH</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_dh tooltip\" title=\"Direção Hidraulica\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Manual</span>                                    <span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_cambio tooltip\" title=\"Câmbio\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Motor 1.0</span><span class=\"sprite_caracteristicas sprite_caracteristicas_motor arruma_icones_desk tooltip\" title=\"Motor\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Som</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_som tooltip\" title=\"Som\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\"> 4 portas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_portas arruma_icones_desk tooltip\" title=\"Portas\" ></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">2p. 1g.</span><span class=\"sprite_caracteristicas sprite_caracteristicas_malas arruma_icones_desk tooltip\" title=\"Numero de malas\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">5 pessoas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_pessoas arruma_icones_desk tooltip\" title=\"Passageiros\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">AirBag</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_airbag tooltip\" title=\"Airbag\"></span></div>&nbsp;&nbsp;</div></div></div><div class=\"row\"  style=\"width: 110% !important;  margin-left: 180px; margin-top: 20px;\"><div class=\"medium-8 large-8 columns\" style=\"padding: 0 30px; margin-top: 15px;\"><p class=\"franquia_line\"><span style=\"font-weight: bold;\">Caução:</span> R$ 700,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</p></div><div class=\"medium-4 large-4 columns\" style=\"padding-top: 10px; text-align:right; \"></div></div></li><li data-orbit-slide=\"headline-3\"><div class=\"frota_orbit2\"><div class=\"medium-6 large-6 columns\"><h3 class=\"arruma_imagens_frotaNova\"><ul class=\"example-orbit-content\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center><img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/onix.png\" alt=\"Onix, Fox ou similar\" title=\"Onix, Fox ou similar\" style=\"max-height:240px\"/></center></li><li data-orbit-slide=\"headline-2\"><center><img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/fox.png\" alt=\"Onix, Fox ou similar\" title=\"Onix, Fox ou similar\" style=\"max-height:240px\"/></center></li></ul></h3></div><div class=\"medium-6 large-6 columns\"><h3 style=\"margin-bottom: 10px; margin-left: -2px; margin-top: 16px;\">Básico + AR + DH</h3><h2 class=\"nomes_dos_carros\">Onix, Fox ou similar</h2><hr style=\"margin-bottom: 20px !important;\"><div class=\"row\" style=\"margin-top: -10px !important;\"><button type=\"submit\" class=\"buscar_cotacao\" style=\"    margin-top: 13px !important;\">Verifique preços e disponibilidade</button></div></div></div><div class=\"row collapse\" style=\"margin-top: -290px; margin-left: 20px;\"><div class=\"medium-12 large-12 columns\" style=\"text-align: center;\"><div style=\"width: 100%;\"><div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Ar</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_ar tooltip\" title=\"Ar condicionado\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">DH</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_dh tooltip\" title=\"Direção Hidraulica\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Manual</span>                                    <span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_cambio tooltip\" title=\"Câmbio\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Motor 1.0</span><span class=\"sprite_caracteristicas sprite_caracteristicas_motor arruma_icones_desk tooltip\" title=\"Motor\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Som</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_som tooltip\" title=\"Som\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\"> 4 portas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_portas arruma_icones_desk tooltip\" title=\"Portas\" ></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">1p. 1g.</span><span class=\"sprite_caracteristicas sprite_caracteristicas_malas arruma_icones_desk tooltip\" title=\"Numero de malas\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">5 pessoas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_pessoas arruma_icones_desk tooltip\" title=\"Passageiros\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">AirBag</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_airbag tooltip\" title=\"Airbag\"></span></div>&nbsp;&nbsp;</div></div></div><div class=\"row\"  style=\"width: 110% !important;  margin-left: 180px; margin-top: 20px;\"><div class=\"medium-8 large-8 columns\" style=\"padding: 0 30px; margin-top: 15px;\"><p class=\"franquia_line\"><span style=\"font-weight: bold;\">Caução:</span> R$ 700,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</p></div><div class=\"medium-4 large-4 columns\" style=\"padding-top: 10px; text-align:right; \"></div></div></li><li data-orbit-slide=\"headline-4\"><div class=\"frota_orbit2\"><div class=\"medium-6 large-6 columns\"><h3 class=\"arruma_imagens_frotaNova\"><ul class=\"example-orbit-content\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center><img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/fox.png\" alt=\"Fox, Sandero ou similar\" title=\"Fox, Sandero ou similar\" style=\"max-height:240px\"/></center></li><li data-orbit-slide=\"headline-2\"><center><img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/sandero.png\" alt=\"Fox, Sandero ou similar\" title=\"Fox, Sandero ou similar\" style=\"max-height:240px\"/></center></li></ul></h3></div><div class=\"medium-6 large-6 columns\"><h3 style=\"margin-bottom: 10px; margin-left: -2px; margin-top: 16px;\">Compacto</h3><h2 class=\"nomes_dos_carros\">Fox, Sandero ou similar</h2><hr style=\"margin-bottom: 20px !important;\"><div class=\"row\" style=\"margin-top: -10px !important;\"><button type=\"submit\" class=\"buscar_cotacao\" style=\"    margin-top: 13px !important;\">Verifique preços e disponibilidade</button></div></div></div><div class=\"row collapse\" style=\"margin-top: -290px; margin-left: 20px;\"><div class=\"medium-12 large-12 columns\" style=\"text-align: center;\"><div style=\"width: 100%;\"><div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Ar</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_ar tooltip\" title=\"Ar condicionado\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">DH</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_dh tooltip\" title=\"Direção Hidraulica\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Manual</span>                                    <span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_cambio tooltip\" title=\"Câmbio\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Motor 1.6</span><span class=\"sprite_caracteristicas sprite_caracteristicas_motor arruma_icones_desk tooltip\" title=\"Motor\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Som</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_som tooltip\" title=\"Som\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\"> 4 portas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_portas arruma_icones_desk tooltip\" title=\"Portas\" ></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">2p. 2g.</span><span class=\"sprite_caracteristicas sprite_caracteristicas_malas arruma_icones_desk tooltip\" title=\"Numero de malas\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">5 pessoas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_pessoas arruma_icones_desk tooltip\" title=\"Passageiros\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">AirBag</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_airbag tooltip\" title=\"Airbag\"></span></div>&nbsp;&nbsp;</div></div></div><div class=\"row\"  style=\"width: 110% !important;  margin-left: 180px; margin-top: 20px;\"><div class=\"medium-8 large-8 columns\" style=\"padding: 0 30px; margin-top: 15px;\"><p class=\"franquia_line\"><span style=\"font-weight: bold;\">Caução:</span> R$ 1.000,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</p></div><div class=\"medium-4 large-4 columns\" style=\"padding-top: 10px; text-align:right; \"></div></div></li><li data-orbit-slide=\"headline-5\"><div class=\"frota_orbit2\"><div class=\"medium-6 large-6 columns\"><h3 class=\"arruma_imagens_frotaNova\"><ul class=\"example-orbit-content\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center><img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/voyage.png\" alt=\"Voyage, Cobalt ou similar\" title=\"Voyage, Cobalt ou similar\" style=\"max-height:240px\"/></center></li><li data-orbit-slide=\"headline-2\"><center><img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/cobalt.png\" alt=\"Voyage, Cobalt ou similar\" title=\"Voyage, Cobalt ou similar\" style=\"max-height:240px\"/></center></li></ul></h3></div><div class=\"medium-6 large-6 columns\"><h3 style=\"margin-bottom: 10px; margin-left: -2px; margin-top: 16px;\">Sedan Compacto</h3><h2 class=\"nomes_dos_carros\">Voyage, Cobalt ou similar</h2><hr style=\"margin-bottom: 20px !important;\"><div class=\"row\" style=\"margin-top: -10px !important;\"><button type=\"submit\" class=\"buscar_cotacao\" style=\"    margin-top: 13px !important;\">Verifique preços e disponibilidade</button></div></div></div><div class=\"row collapse\" style=\"margin-top: -290px; margin-left: 20px;\"><div class=\"medium-12 large-12 columns\" style=\"text-align: center;\"><div style=\"width: 100%;\"><div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Ar</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_ar tooltip\" title=\"Ar condicionado\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">DH</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_dh tooltip\" title=\"Direção Hidraulica\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Manual</span>                                    <span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_cambio tooltip\" title=\"Câmbio\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Motor 1.6</span><span class=\"sprite_caracteristicas sprite_caracteristicas_motor arruma_icones_desk tooltip\" title=\"Motor\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Som</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_som tooltip\" title=\"Som\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\"> 4 portas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_portas arruma_icones_desk tooltip\" title=\"Portas\" ></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">2p. 2g.</span><span class=\"sprite_caracteristicas sprite_caracteristicas_malas arruma_icones_desk tooltip\" title=\"Numero de malas\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">5 pessoas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_pessoas arruma_icones_desk tooltip\" title=\"Passageiros\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">AirBag</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_airbag tooltip\" title=\"Airbag\"></span></div>&nbsp;&nbsp;</div></div></div><div class=\"row\"  style=\"width: 110% !important;  margin-left: 180px; margin-top: 20px;\"><div class=\"medium-8 large-8 columns\" style=\"padding: 0 30px; margin-top: 15px;\"><p class=\"franquia_line\"><span style=\"font-weight: bold;\">Caução:</span> R$ 1.000,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</p></div><div class=\"medium-4 large-4 columns\" style=\"padding-top: 10px; text-align:right; \"></div></div></li><li data-orbit-slide=\"headline-6\"><div class=\"frota_orbit2\"><div class=\"medium-6 large-6 columns\"><h3 class=\"arruma_imagens_frotaNova\"><ul class=\"example-orbit-content\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center><img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/doblo.png\" alt=\"Doblò  ou similar\" title=\"Doblò  ou similar\" style=\"max-height:240px\"/></center></li></ul></h3></div><div class=\"medium-6 large-6 columns\"><h3 style=\"margin-bottom: 10px; margin-left: -2px; margin-top: 16px;\">Van Média</h3><h2 class=\"nomes_dos_carros\">Doblò  ou similar</h2><hr style=\"margin-bottom: 20px !important;\"><div class=\"row\" style=\"margin-top: -10px !important;\"><button type=\"submit\" class=\"buscar_cotacao\" style=\"    margin-top: 13px !important;\">Verifique preços e disponibilidade</button></div></div></div><div class=\"row collapse\" style=\"margin-top: -290px; margin-left: 20px;\"><div class=\"medium-12 large-12 columns\" style=\"text-align: center;\"><div style=\"width: 100%;\"><div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Ar</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_ar tooltip\" title=\"Ar condicionado\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">DH</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_dh tooltip\" title=\"Direção Hidraulica\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Manual</span>                                    <span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_cambio tooltip\" title=\"Câmbio\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Motor 1.4</span><span class=\"sprite_caracteristicas sprite_caracteristicas_motor arruma_icones_desk tooltip\" title=\"Motor\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Som</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_som tooltip\" title=\"Som\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\"> 4 portas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_portas arruma_icones_desk tooltip\" title=\"Portas\" ></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">2p. 3g.</span><span class=\"sprite_caracteristicas sprite_caracteristicas_malas arruma_icones_desk tooltip\" title=\"Numero de malas\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">7 pessoas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_pessoas arruma_icones_desk tooltip\" title=\"Passageiros\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">AirBag</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_airbag tooltip\" title=\"Airbag\"></span></div>&nbsp;&nbsp;</div></div></div><div class=\"row\"  style=\"width: 110% !important;  margin-left: 180px; margin-top: 20px;\"><div class=\"medium-8 large-8 columns\" style=\"padding: 0 30px; margin-top: 15px;\"><p class=\"franquia_line\"><span style=\"font-weight: bold;\">Caução:</span> R$ 1.500,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</p></div><div class=\"medium-4 large-4 columns\" style=\"padding-top: 10px; text-align:right; \"></div></div></li><li data-orbit-slide=\"headline-7\"><div class=\"frota_orbit2\"><div class=\"medium-6 large-6 columns\"><h3 class=\"arruma_imagens_frotaNova\"><ul class=\"example-orbit-content\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center><img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/spin.png\" alt=\"Spin ou similar\" title=\"Spin ou similar\" style=\"max-height:240px\"/></center></li></ul></h3></div><div class=\"medium-6 large-6 columns\"><h3 style=\"margin-bottom: 10px; margin-left: -2px; margin-top: 16px;\">Van Compacta</h3><h2 class=\"nomes_dos_carros\">Spin ou similar</h2><hr style=\"margin-bottom: 20px !important;\"><div class=\"row\" style=\"margin-top: -10px !important;\"><button type=\"submit\" class=\"buscar_cotacao\" style=\"    margin-top: 13px !important;\">Verifique preços e disponibilidade</button></div></div></div><div class=\"row collapse\" style=\"margin-top: -290px; margin-left: 20px;\"><div class=\"medium-12 large-12 columns\" style=\"text-align: center;\"><div style=\"width: 100%;\"><div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Ar</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_ar tooltip\" title=\"Ar condicionado\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">DH</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_dh tooltip\" title=\"Direção Hidraulica\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Auto</span>                                    <span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_cambio tooltip\" title=\"Câmbio\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Motor 1.8</span><span class=\"sprite_caracteristicas sprite_caracteristicas_motor arruma_icones_desk tooltip\" title=\"Motor\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Som</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_som tooltip\" title=\"Som\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\"> 4 portas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_portas arruma_icones_desk tooltip\" title=\"Portas\" ></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">1p. 1g.</span><span class=\"sprite_caracteristicas sprite_caracteristicas_malas arruma_icones_desk tooltip\" title=\"Numero de malas\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">7 pessoas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_pessoas arruma_icones_desk tooltip\" title=\"Passageiros\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">AirBag</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_airbag tooltip\" title=\"Airbag\"></span></div>&nbsp;&nbsp;</div></div></div><div class=\"row\"  style=\"width: 110% !important;  margin-left: 180px; margin-top: 20px;\"><div class=\"medium-8 large-8 columns\" style=\"padding: 0 30px; margin-top: 15px;\"><p class=\"franquia_line\"><span style=\"font-weight: bold;\">Caução:</span> R$ 1.500,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</p></div><div class=\"medium-4 large-4 columns\" style=\"padding-top: 10px; text-align:right; \"></div></div></li><li data-orbit-slide=\"headline-8\"><div class=\"frota_orbit2\"><div class=\"medium-6 large-6 columns\"><h3 class=\"arruma_imagens_frotaNova\"><ul class=\"example-orbit-content\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center><img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/corola.png\" alt=\"Corolla, Cruze  ou similar\" title=\"Corolla, Cruze  ou similar\" style=\"max-height:240px\"/></center></li><li data-orbit-slide=\"headline-2\"><center><img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/cruze.png\" alt=\"Corolla, Cruze  ou similar\" title=\"Corolla, Cruze  ou similar\" style=\"max-height:240px\"/></center></li></ul></h3></div><div class=\"medium-6 large-6 columns\"><h3 style=\"margin-bottom: 10px; margin-left: -2px; margin-top: 16px;\">Automático</h3><h2 class=\"nomes_dos_carros\">Corolla, Cruze  ou similar</h2><hr style=\"margin-bottom: 20px !important;\"><div class=\"row\" style=\"margin-top: -10px !important;\"><button type=\"submit\" class=\"buscar_cotacao\" style=\"    margin-top: 13px !important;\">Verifique preços e disponibilidade</button></div></div></div><div class=\"row collapse\" style=\"margin-top: -290px; margin-left: 20px;\"><div class=\"medium-12 large-12 columns\" style=\"text-align: center;\"><div style=\"width: 100%;\"><div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Ar</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_ar tooltip\" title=\"Ar condicionado\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">DH</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_dh tooltip\" title=\"Direção Hidraulica\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Auto</span>                                    <span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_cambio tooltip\" title=\"Câmbio\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Motor 2.0</span><span class=\"sprite_caracteristicas sprite_caracteristicas_motor arruma_icones_desk tooltip\" title=\"Motor\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Som</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_som tooltip\" title=\"Som\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\"> 4 portas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_portas arruma_icones_desk tooltip\" title=\"Portas\" ></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">2p. 2g.</span><span class=\"sprite_caracteristicas sprite_caracteristicas_malas arruma_icones_desk tooltip\" title=\"Numero de malas\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">5 pessoas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_pessoas arruma_icones_desk tooltip\" title=\"Passageiros\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">AirBag</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_airbag tooltip\" title=\"Airbag\"></span></div>&nbsp;&nbsp;</div></div></div><div class=\"row\"  style=\"width: 110% !important;  margin-left: 180px; margin-top: 20px;\"><div class=\"medium-8 large-8 columns\" style=\"padding: 0 30px; margin-top: 15px;\"><p class=\"franquia_line\"><span style=\"font-weight: bold;\">Caução:</span> R$ 4.000,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</p></div><div class=\"medium-4 large-4 columns\" style=\"padding-top: 10px; text-align:right; \"></div></div></li><li data-orbit-slide=\"headline-9\"><div class=\"frota_orbit2\"><div class=\"medium-6 large-6 columns\"><h3 class=\"arruma_imagens_frotaNova\"><ul class=\"example-orbit-content\" data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false;\"><li data-orbit-slide=\"headline-1\"><center><img src=\"//www.carroaluguel.com/images/carroaluguel/cotacao/carros/duster.png\" alt=\"Duster ou similar\" title=\"Duster ou similar\" style=\"max-height:240px\"/></center></li></ul></h3></div><div class=\"medium-6 large-6 columns\"><h3 style=\"margin-bottom: 10px; margin-left: -2px; margin-top: 16px;\">SUV Compacta</h3><h2 class=\"nomes_dos_carros\">Duster ou similar</h2><hr style=\"margin-bottom: 20px !important;\"><div class=\"row\" style=\"margin-top: -10px !important;\"><button type=\"submit\" class=\"buscar_cotacao\" style=\"    margin-top: 13px !important;\">Verifique preços e disponibilidade</button></div></div></div><div class=\"row collapse\" style=\"margin-top: -290px; margin-left: 20px;\"><div class=\"medium-12 large-12 columns\" style=\"text-align: center;\"><div style=\"width: 100%;\"><div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Ar</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_ar tooltip\" title=\"Ar condicionado\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">DH</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_dh tooltip\" title=\"Direção Hidraulica\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Manual</span>                                    <span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_cambio tooltip\" title=\"Câmbio\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Motor 1.6</span><span class=\"sprite_caracteristicas sprite_caracteristicas_motor arruma_icones_desk tooltip\" title=\"Motor\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">Som</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_som tooltip\" title=\"Som\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\"> 4 portas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_portas arruma_icones_desk tooltip\" title=\"Portas\" ></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">3p. 3g.</span><span class=\"sprite_caracteristicas sprite_caracteristicas_malas arruma_icones_desk tooltip\" title=\"Numero de malas\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">5 pessoas</span><span class=\"sprite_caracteristicas sprite_caracteristicas_pessoas arruma_icones_desk tooltip\" title=\"Passageiros\"></span></div>&nbsp;&nbsp;<div class=\"adicionais_icon\"><span class=\"textos_icons_frota\">AirBag</span><span class=\"sprite_caracteristicas arruma_icones_desk sprite_caracteristicas_airbag tooltip\" title=\"Airbag\"></span></div>&nbsp;&nbsp;</div></div></div><div class=\"row\"  style=\"width: 110% !important;  margin-left: 180px; margin-top: 20px;\"><div class=\"medium-8 large-8 columns\" style=\"padding: 0 30px; margin-top: 15px;\"><p class=\"franquia_line\"><span style=\"font-weight: bold;\">Caução:</span> R$ 1.500,00 - Caução é uma garantia que o fornecedor solicita para deduzir despesas não previstas, ou se ressarcir de algo que precise ser consertado ou substituído, quando da utilização de um serviço ou produto por um determinado tempo.</p></div><div class=\"medium-4 large-4 columns\" style=\"padding-top: 10px; text-align:right; \"></div></div></li></ul><div class=\"row\" style=\"margin: -30px 0 40px;\"><div class=\"medium-12 large-12 columns entra_orbit_3\" style=\"margin-bottom: -20px;\"><h2 class=\"acessorios_title\" style=\"text-align: center;margin-bottom:20px; margin-top: -60px;\">Confira os extras oferecidos pela Sucesso Rent a Car</h2><ul class=\"orbit-container\" data-orbit data-options=\"animation:fade;bullets:true;timer:false;navigation_arrows:false;\"><li><div class=\"opcionais_orbit\"><div class=\"row\"><div class=\"medium-12 large-12 columns\"><div style=\"width: 100%; text-align: center; margin-left: 50px;\" ><div class=\"acessorio_unit\"><img src=\"//www.carroaluguel.tur.br/images/carroaluguel/lp-locadoras/acessorios_gps.jpg\" style=\"width: 50%;\"/><div class=\"acessorios_text\"><span class=\"acessorios_title_loja_locadora\">GPS</span><span class=\"acessorios_desc_loja_locadora \">Navegação digital</span><span class=\"acessorios_preco_loja_locadora\">R$ 15 <span>a diária</span></div></div><hr size=\"150\" width=\"1\" class=\"hr_acessorios_ne\"><div class=\"acessorio_unit\"><img src=\"//www.carroaluguel.tur.br/images/carroaluguel/lp-locadoras/acessorios_cadeira.jpg\" style=\"width: 50%;\"/><div class=\"acessorios_text\"><span class=\"acessorios_title_loja_locadora\">Cadeira Segurança</span><span class=\"acessorios_desc_loja_locadora\">Crianças entre 1 e 4 anos</span><span class=\"acessorios_preco_loja_locadora\">R$ 12 <span>a diária</span></div></div><hr size=\"150\" width=\"1\" class=\"hr_acessorios_ne\"><div class=\"acessorio_unit\"><img src=\"//www.carroaluguel.tur.br/images/carroaluguel/lp-locadoras/acessorios_assento.jpg\" style=\"width: 50%;\"/><div class=\"acessorios_text\"><span class=\"acessorios_title_loja_locadora\">Assento de elevação</span><span class=\"acessorios_desc_loja_locadora\">Crianças entre 4 e 7 anos</span><span class=\"acessorios_preco_loja_locadora\">R$ 12 <span>a diária</span></div></div><hr size=\"150\" width=\"1\" class=\"hr_acessorios_ne\"><div class=\"acessorio_unit\"><img src=\"//www.carroaluguel.tur.br/images/carroaluguel/lp-locadoras/acessorios_condutor.jpg\" style=\"width: 50%;\"/><div class=\"acessorios_text\"><span class=\"acessorios_title_loja_locadora\">Condutor Adicional</span><span class=\"acessorios_desc_loja_locadora\">O número de condutores adicionais varia por locadora, consulte nossa equipe de atendimento</span><span class=\"acessorios_preco_loja_locadora\">R$ 10 <span>a diária</span></div></div></div></div></div></div></li></ul></div></div></div></div><div class=\"large-12 columns linha_titulos2 hide-for-small hide-for-medium\"><span class=\"titulo_tarifas\">Proteções ofertadas pela Sucesso Recife loja Imbiribeira.</span></div><div class=\"large-12 columns protecoes_design hide-for-small hide-for-medium\"><div id=\"protecoes\" class=\"row inner-accordion\" style=\"display:block\"><div class=\"medium-1 large-1 columns\"><span class=\"sprite_header sprite_protecao\"></span></div><div class=\"medium-11 large-11 columns\"><div class=\"arruma_paragrafo\"><h3>Proteção parcial do carro <span class=\"mbl_fundo_laranja\">Inclusa na diária</span></h3><div class=\"protecao_desc\">Para os grupos <a href=\"javascript:void(0)\" data-tooltip=\"Básico + AR + DH\">B</a>, <a href=\"javascript:void(0)\" data-tooltip=\"Básico + AR + DH\">C</a>, <a href=\"javascript:void(0)\" data-tooltip=\"Compacto\">D</a>, <a href=\"javascript:void(0)\" data-tooltip=\"Sedan Compacto\">E</a>, <a href=\"javascript:void(0)\" data-tooltip=\"Van Compacta\">F</a>, <a href=\"javascript:void(0)\" data-tooltip=\"SUV Compacta\">G</a>, <a href=\"javascript:void(0)\" data-tooltip=\"Van Média\">I</a>, <a href=\"javascript:void(0)\" data-tooltip=\"Automático\">J</a>: <p>Prote&ccedil;&atilde;o ao ve&iacute;culo locado para avarias, colis&otilde;es, roubo, furto, inc&ecirc;ndio e perda total, cabendo ao locat&aacute;rio arcar com a coparticipa&ccedil;&atilde;o estabelecida em contrato de at&eacute; 10% para colis&otilde;es e acidentes e 20% para roubo, inc&ecirc;ndio e perda total, ambos calculados sobre o pre&ccedil;o de tabela vigente do ve&iacute;culo zero quilometro.</p></div></div></div><div class=\"medium-1 large-1 columns\"></div><div class=\"medium-11 large-11 columns\"><div><div class=\"protecao_desc\" style=\"font-size: 14px;\"><span class=\"protecoes_aviso\" style=\"display:block;color:#ff0000;margin: 10px 0;font-weight: bold;\">IMPORTANTE</span>Ficam sob inteira responsabilidade do CLIENTE, (<b>uma vez que os itens a seguir não estão cobertos por quaisquer proteções</b>) os equipamentos e acessórios (faróis, lanternas, espelhos retrovisores internos e externos, rádio, compact disk (CD player), pneus, rodas de ferro ou liga leve, triângulo, chaves de roda, macaco compatível com o peso e carga do veículo, extintor de incêndio, acendedor de cigarros, protetor de cárter, bateria, capotas de fibra, chaves do veículo, estofamentos, calotas, antena, estepe completo com ou sem câmara de ar, jogo de tapetes, para-sol, assentos e forrações danificadas, vidros inclusive danos ao pára-brisa, grades e documentos do veiculo CRLV), não podendo ser substituídos ou inutilizados, a não ser quando expressamente autorizado pela LOCADORA. Nos casos de comprovada imperícia, imprudência, desobediência às leis de trânsito, ou utilização indevida do veículo, e/ou a não entrega do BO (Boletim de Ocorrência) no prazo de 24 horas, representarão perda da cobertura, passando o locatário a arcar com as despesas integrais do dano ao veículo.</div></div><br></div></div></div><div class=\"large-12 columns linha_titulos3 hide-for-small hide-for-medium\"><span class=\"titulo_tarifas\">Formas de pagamento aceitas pela Sucesso Recife loja Imbiribeira.</span></div><div class=\"large-12 columns pagamento_design hide-for-small hide-for-medium\"><div id=\"pagamento\" class=\"row inner-accordion\" style=\"display: block;\"><div class=\"medium-12 large-12 columns\">A Sucesso Rent a Car aceita pagamentos apenas com cartão de crédito, é possível dividir em até 3 vezes sem juros e a parcela mínima é de R$ 500,00.<br>Bandeiras aceitas:<span class=\"sprite_cc mbl_sprite_cc_visa\"></span><span class=\"sprite_cc mbl_sprite_cc_master\"></span><span class=\"sprite_cc mbl_sprite_cc_american\"></span><span class=\"sprite_cc mbl_sprite_cc_hiper\"></span><span class=\"sprite_cc mbl_sprite_cc_dinners\"></span><br><br></div></div></div><div class=\"large-12 columns linha_titulos2 hide-for-small hide-for-medium\"><span class=\"titulo_tarifas\">Verifique a Localização</span></div><div class=\"large-12 columns sumir_mbl_3 hide-for-small hide-for-medium\"><div class=\"large-12\" columns><div class=\"large-12\" columns><form method=\"post\"><div class=\"large-6\" columns><div><label for=\"txtEnderecoPartida\" class=\"titulo_maps\">Digite aqui seu endereço para ver a rota da sua casa até a locadora:</label></div></div><div class=\"large-6\" columns><div class=\"arruma_search_maps\"><input type=\"text\" id=\"txtEnderecoPartida\" name=\"txtEnderecoPartida\" class=\"text_maps\" /><input type=\"submit\" id=\"btnEnviar\" name=\"btnEnviar\" value=\"\" class=\"search_maps\" /><input type=\"hidden\" id=\"hdnOrigem\" name=\"hdnOrigem\"/><input type=\"hidden\" id=\"hdnDestino\" name=\"hdnDestino\" value=\"Av. Mal. Mascarenhas de Morais, 5855Recife\"/><input type=\"hidden\" id=\"hdnDestinoLatiLong\" name=\"hdnDestinoLatiLong\" value=\"-8.135045 -34.916344\"/></div></div></form></div><div class=\"large-12 mostra_origem_dest hide\" columns><div class=\"origem_dest\"><img src=\"//www.carroaluguel.com/images/carroaluguel/tick_A.png\" style=\"display: block;\"><div class=\"arruma_origem\"><span class=\"texto_origem\">Origem:</span> <span id=\"texto_origem\"></span></div></img><span class=\"texto_destino2\"><img src=\"//www.carroaluguel.com/images/carroaluguel/tick_B.png\" ><span class=\"texto_destino\">Destino:</span> Av. Mal. Mascarenhas de Morais, 5855Recife</img></span></div></div><div id=\"mapa\"></div></div><div class=\"large-12\" columns style=\"margin-bottom: 15px; margin-top: -10px;\"><span class=\"ver_outras_maps\">Para ver outras lojas da Sucesso Rent a Car em Recife,</span> <a class=\"modal_outrosLocais\">clique aqui.</a></div><div class=\"large-12 columns localizacao_locadoras\"><div class=\"row\"><div class=\"large-6 columns\"><ul class=\"orbit-container\"  data-orbit data-options=\"bullets:true;timer:false;navigation_arrows:false\"><li><div class=\"opcionais_orbit\" style=\"margin-left: -174px;\"><div class=\"medium-12 large-12 columns alinhamento_figuras\"><div style=\"width: 100%; text-align: center; margin-left: 110px;\"><div class=\"conteudo_figuras\"><img src=\"http://placehold.it/530x250&text=Imagem temporária\"></div></div></div></div></li></ul></div><div class=\"large-6 columns espacador_loc\"><span class=\"titulos_loc\" style=\"margin-top: 20px;\">Endereço: </span> Av. Mal. Mascarenhas de Morais, 5855 |&nbsp;<span class=\"titulos_loc\">Bairro:</span> Imbiribeira |&nbsp;<span class=\"titulos_loc\">Cidade:</span> Recife |&nbsp;<span class=\"titulos_loc\">Estado:</span> Pernambuco<br><br><span class=\"titulos_loc\">Horários: </span>Segunda à sexta-feira das 0h às 23h |&nbsp;Sábados das 0h às 23h<br><br><span class=\"titulos_loc\">Reserve também pelo nossos telefones:</span><br>4062 0633</div></div></div></div><div class=\"large-12 columns linha_titulos2 hide-for-small hide-for-medium\"><span class=\"titulo_tarifas\">Avaliações e depoimentos para a </span></div><div class=\"large-12 columns espacador_titulos hide-for-small hide-for-medium\"><span class=\"titulo_avaliacao\"> Avaliações: </span><span class=\"descricao_avaliacao\"> Conservação dos carros <img src=\"/images/carroaluguel/responsivo/aval_star/aval_8.png\" align=\"absmiddle\" width=\"73\" height=\"13\" alt=\"73.6\" /></span><span class=\"descricao_avaliacao2\"> Qualidade de atendimento <img src=\"/images/carroaluguel/responsivo/aval_star/aval_8.png\" align=\"absmiddle\" width=\"73\" height=\"13\" alt=\"73.6\" /></span></div><div class=\"large-12 columns sumir_mbl_4 hide-for-small hide-for-medium\"><div class=\"large-8 columns\"><div class=\"fundo_ultimos_coments\"><span class=\"titulo_ultimos_coments\">Últimos comentários</span></div></div><div class=\"coments_orbit\"><ul class=\"orbit-container\"  data-orbit data-options=\"bullets:false;timer:false;\"><li><div class=\"opcionais_orbit\" style=\"width: 1240px;text-align: center;margin-left: -120px;\"><div class=\"medium-12 large-12 columns alinhamento_texto\"><div style=\"width: 100%; text-align: center; margin-left: 130px;\"><div class=\"acessorio_unit2\"><</div></div></div></div></li></ul></div></div><hr class=\"hr_fim_coments hide-for-small hide-for-medium\"></div><div id=\"bio_ep\" class=\"popUpBlack\"><div class=\"row\" style=\"display:block; text-align: center;\"><input type=\"text\" placeholder=\"Digite aqui o seu e-mail\" id=\"black_email\" class=\"imputBlack\"></div><div class=\"row\" style=\"display:block; text-align: center;\"><img style=\"position: absolute;  margin-top: -56px; margin-left: 50px; cursor: pointer; display: inline-block;\" class=\"botaoBlack\" src=\"//www.carroaluguel.com/images/cta-pop-up.png\"></img></div></div><footer style=\"margin-bottom: -18px;\"><div class=\"show-for-small-only\" style=\"text-align: center;\"><div class=\"row\"><div class=\"small-12 columns\" style=\"margin: 20px 0;\"><span style=\"font-size:22px;font-weight:bold;color:#005a9f;display: block;\">Dúvidas com a reserva?</span><span style=\"font-size:16px;font-weight:bold;color:#595959;display: block; margin:5px;\">Reservar por telefone</span></div></div><div class=\"row\"><div class=\"small-12 columns\"><div style=\"max-width:250px; padding: 20px;background-color: #8ee000;border-radius: 10px;margin: 20px auto;cursor:pointer\" onclick=\"window.location.href = \'/telefones-atendimento\'\"><a style=\"font-size:25px;font-weight:bold;color:#005a9f;display: block;\" href=\"tel:\"></a><span style=\"font-size:12px;font-weight:bold;color:#595959;display: block;margin:5px;\">Não é seu DDD? Clique aqui</span></div></div></div><div class=\"row\"><div class=\"medium-12 small-12 columns\" style=\"margin-bottom: 20px;\"><a href=\"http://www.carroaluguel.com\" style=\"text-align: center\"><img id=\"logo\" src=\"//carroaluguel.tur.br/images/carroaluguel/funilreservas/logo.png\" style=\"border: none;\" alt=\"CarroAluguel.com - A melhor maneira de alugar um carro\"/></a></div></div></div><div class=\"show-for-medium-up\"><div class=\"bg-footer\" style=\"padding-bottom: 5px;\"><div class=\"linha\"><div class=\"coluna-3\"><div class=\"links\"><h3 class=\"cufon\">Locadoras Parceiras</h3><ul style=\"line-height: 1.5em;\"><li class=\"cor-clara\"><a href=\"/unidas-rent-a-car\">Unidas</a></li><li class=\"cor-escura\"><a href=\"/lokamig-rent-a-car\">Lokamig</a></li><li class=\"cor-clara\"><a href=\"/localiza-rent-a-car\">Localiza</a></li><li class=\"cor-escura\"><a href=\"/avis-rent-a-car\">Avis</a></li><li class=\"cor-clara\"><a href=\"/alamo-rent-a-car\">Alamo</a></li><li class=\"cor-escura\"><a href=\"/karper-rent-a-car\">Karper Rent a Car</a></li><li class=\"cor-clara\"><a href=\"/gold-car-rentals\">Gold Car</a></li><li class=\"cor-escura\"><a href=\"/movida-rent-a-car\">Movida</a></li><li class=\"cor-clara\"><a href=\"/thrifty-rent-a-car\">Thrifty</a></li><li class=\"cor-clara\"><a href=\"/budget-rent-a-car\">Budget Rent a Car</a></li><li class=\"cor-escura\"><a href=\"/yes-rent-a-car\">Yes Rent a Car</a></li><li class=\"cor-clara\"><a href=\"/ponto-a-ponto-rent-a-car\">Ponto a Ponto Rent a Car</a></li><li class=\"cor-escura\"><a href=\"/alugue-brasil-rent-a-car\">Alugue Brasil</a></li><li class=\"cor-clara\"><a href=\"/mister-car-rent-a-car\">Mister Car</a></li><li class=\"cor-escura\"><a href=\"/foco-rent-a-car\">Foco Aluguel de Carros</a></li></ul><p class=\"link-mais\" style=\"margin-bottom: 0px;\"><a href=\"/locadoras-de-veiculos\">Veja mais autolocadoras</a></p></div></div><div class=\"coluna-3\"><div class=\"links\"><h3 class=\"cufon\">Cidades Atendidas</h3><ul style=\"line-height: 1.5em;\" itemprop=\"address\" itemscope itemtype=\"http://schema.org/PostalAddress\"><li itemprop=\"addressLocality\" class=\"cor-clara\"><a href=\"/aluguel-de-carros-no-rio-de-janeiro\">Aluguel de carros RJ</a></li><li itemprop=\"addressLocality\" class=\"cor-escura\"><a href=\"/aluguel-de-carros-em-sao-paulo\">Aluguel de carros SP</a></li><li itemprop=\"addressLocality\" class=\"cor-clara\"><a href=\"/aluguel-de-carros-em-salvador\">Aluguel de carros Salvador</a></li><li itemprop=\"addressLocality\" class=\"cor-escura\"><a href=\"/aluguel-de-carros-em-curitiba\">Aluguel de carros Curitiba</a></li><li itemprop=\"addressLocality\" class=\"cor-clara\"><a href=\"/aluguel-de-carros-em-recife\">Aluguel de carros Recife</a></li><li itemprop=\"addressLocality\" class=\"cor-escura\"><a href=\"/aluguel-de-carros-em-porto-alegre\">Aluguel de carros Porto Alegre</a></li><li itemprop=\"addressLocality\" class=\"cor-clara\"><a href=\"/aluguel-de-carros-em-belo-horizonte\">Aluguel de carros em BH</a></li><li itemprop=\"addressLocality\" class=\"cor-escura\"><a href=\"/aluguel-de-carros-em-goiania\">Aluguel de carros Goiânia</a></li><li itemprop=\"addressLocality\" class=\"cor-clara\"><a href=\"/aluguel-de-carros-em-brasilia\">Aluguel de carros DF</a></li><li itemprop=\"addressLocality\" class=\"cor-escura\"><a href=\"/aluguel-de-carros-em-guarulhos\">Aluguel de carros Guarulhos</a></li><li itemprop=\"addressLocality\" class=\"cor-clara\"><a href=\"/aluguel-de-carros-em-manaus\">Aluguel de carros Manaus</a></li><li itemprop=\"addressLocality\" class=\"cor-escura\"><a href=\"/aluguel-de-carros-em-maceio\">Aluguel de carros em Maceió</a></li><li itemprop=\"addressLocality\" class=\"cor-clara\"><a href=\"/aluguel-de-carros-em-cuiaba\">Aluguel de carro Cuiabá</a></li><li itemprop=\"addressLocality\" class=\"cor-escura\"><a href=\"/aluguel-de-carros-em-gramado\">Aluguel de carro em Gramado</a></li><li itemprop=\"addressLocality\" class=\"cor-clara\"><a href=\"/aluguel-de-carros-em-santo-andre\">Aluguel de carro Santo André</a></li><li itemprop=\"addressLocality\" class=\"cor-escura\"><a href=\"/aluguel-de-carros-em-niteroi\">Aluguel de carro Niterói</a></li><li itemprop=\"addressLocality\" class=\"cor-clara\"><a href=\"/aluguel-de-carros-em-belem\">Aluguel de carro em Belém</a></li><li itemprop=\"addressLocality\" class=\"cor-escura\"><a href=\"/aluguel-de-carros-em-fortaleza\">Aluguel de carros em Fortaleza</a></li><li itemprop=\"addressLocality\" class=\"cor-clara\"><a href=\"/aluguel-de-carros-em-florianopolis\">Aluguel de carros em Florianópolis</a></li><li itemprop=\"addressLocality\" class=\"cor-escura\"><a href=\"/aluguel-de-carros-em-natal\">Aluguel de carro em Natal</a></li></ul><p class=\"link-mais\" style=\"margin-bottom: 0px;\"><a href=\"/cidades-disponiveis-para-aluguel-de-carros-no-brasil\">Veja mais cidades atendidas</a></p></div></div><div class=\"coluna-3\"><div class=\"row\"><div class=\"small-12 columns\"><div class=\"links \"><h3 class=\"cufon\">Acompanhe</h3><ul style=\"line-height: 1.5em;\"><li class=\"cor-clara\"><a href=\"/\">Aluguel de Carros</a></li><li class=\"cor-clara\"><a href=\"/locadoras-de-veiculos\">Locadora de Veículos</a></li><li class=\"cor-clara\"><a href=\"/luxo\">Aluguel de Carros de Luxo</a></li><li class=\"cor-clara\"><a href=\"/basico-sem-ar\">Categorias</a></li><li class=\"cor-clara\"><a href=\"/dicas-locacao-de-carro\">Dicas e Requisitos</a></li><li class=\"cor-clara\"><a href=\"/cadastre_sua_locadora.php\">Cadastre sua Locadora</a></li><li class=\"cor-clara\"><a href=\"/blog\">Blog</a></li><li class=\"cor-clara\"><a href=\"/telefones-atendimento\">Contato</a></li></ul><div style=\"margin-left: 33px;margin-top: 30px;\"><span style=\"color: #fff; font-weight: 600;\">Assine nossa newsletter</span><div style=\"margin-top: 5px;\"><input type=\"text\" id=\"email\" style=\"width: 78%; border: 1px solid #000; border-right: 0;\"></input><button id=\"newsletter-ok\" style=\"float: right; margin-top: -35px; width: 20%; height: 33px; padding: 0px; background: #339E00; border: 1px solid #000;\">OK</button></div></div></div></div></div><div class=\"row\" style=\"margin: 15px 0\"><div class=\"small-12 columns\"><a href=\"https://pt-br.facebook.com/CarroAluguel\" style=\"padding-right: 15px;\" target=\"_blank\"><img src=\"//carroaluguel.tur.br/images/carroaluguel/responsivo/facebook_icon.png\"></a><a href=\"https://twitter.com/intent/follow?original_referer=http%3A%2F%2Fwww.carroaluguel.com%2F&region=follow_link&screen_name=carroaluguel&tw_p=followbutton\" style=\"padding-right: 15px;\" target=\"_blank\"><img src=\"//carroaluguel.tur.br/images/carroaluguel/responsivo/twitter_icon.png\"></a><a href=\"https://plus.google.com/+Carroaluguel/posts\" style=\"padding-right: 15px;\" target=\"_blank\"><img src=\"/images/carroaluguel/responsivo/google_icon.png\"></a><a href=\"http://carroaluguel.com/blog\" style=\"padding-right: 15px;\" target=\"_blank\"><img src=\"//carroaluguel.tur.br/images/carroaluguel/responsivo/blog_icon.png\"></a><a href=\"https://www.youtube.com/user/CarroAluguel/videos\" style=\"padding-right: 15px; target=\"_blank\"><img src=\"//carroaluguel.tur.br/images/carroaluguel/responsivo/youtube_icon.png\"></a></div></div><div class=\"\" style=\"margin-top: 10px; margin-left: 1px; display: none;\"><a href=\"http://carroaluguel.com/blog\" target=\"_blank\"><img src=\"/images/carroaluguel/responsivo/confira-nosso-blog.png\" title=\"Confira nosso blog\" alt=\"Configra nosso blog\" style=\"max-width: 80%;\"></a></div><div itemscope itemtype=\"http://schema.org/Organization\" style=\"color:#FFFFFF !important; margin-top:8px;line-height: normal;\"><meta itemprop=\"description\" content=\"Aluguel de Carros em todo o Brasil\"><link itemprop=\"url\" href=\"http://www.carroaluguel.com/\" rel=\"author\"/><a itemprop=\"url\" href=\"http://www.carroaluguel.com/\"><span itemprop=\"name\" style=\"color:#FFFFFF\"><strong>CarroAluguel</strong></span></a><div itemprop=\"address\" itemscope itemtype=\"http://schema.org/PostalAddress\"><span itemprop=\"telephone\">(41) 4062 0633</span> | <span itemprop=\"addressCountry\">Brazil</span></div><a style=\"font-size: 12px; color:#FFFFFF;\" href=\"/telefones-atendimento\">Não é seu DDD? Clique aqui</a></div></div></div></div><div class=\"barra_footer\"><div class=\"row\"><div class=\"small-12 medium-9 columns\" style=\"font-size: 12px;\">Copyright &copy; 2017 CarroAluguel.com. Todos os direitos reservados.</div><div class=\"small-12 medium-3 columns\"><img alt=\"Aluguel de carros em site seguro\" src=\"/images/carroaluguel/responsivo/site-seguro.png\" border=\"0\" /></div></div></div></div></footer><link rel=\'stylesheet\' type=\'text/css\' href=\'/foundation-5/css/foundation.min.css\'/><link rel=\'stylesheet\' type=\'text/css\' href=\'/css/carroaluguel/jquery-ui.min.css\'/><link rel=\'stylesheet\' type=\'text/css\' href=\'/css/validationEngine.jquery.css\'/><link rel=\'stylesheet\' type=\'text/css\' href=\'/css/carroaluguel/cotacao/default.css\'/><link rel=\'stylesheet\' type=\'text/css\' href=\'/css/carroaluguel/cotacao/default.date.css\'/><link rel=\'stylesheet\' type=\'text/css\' href=\'/css/carroaluguel/cotacao/default.time.css\'/><link rel=\'stylesheet\' type=\'text/css\' href=\'/css/carroaluguel/icones_acessorios.min.css\'/><link rel=\'stylesheet\' type=\'text/css\' href=\'/css/carroaluguel/imagens_opcionais.min.css\'/><link rel=\'stylesheet\' type=\'text/css\' href=\'/css/carroaluguel/lp-locadoras/locadoras.min.css?rand=1261241515\'/><link rel=\'stylesheet\' type=\'text/css\' href=\'/css/carroaluguel/lp-locadoras/sprite_logos_locadoras.min.css?rand=1781335861\'/><link rel=\'stylesheet\' type=\'text/css\' href=\'/css/autocomplete_carro.css\'/><link rel=\'stylesheet\' type=\'text/css\' href=\'/css/carroaluguel/lp-locadoras/style-locadora-cidade-lojas.css?rand=928634161\'/><link rel=\'stylesheet\' type=\'text/css\' href=\'/css/carroaluguel/lp-locadoras/sweetalert2.css\'/><link rel=\'stylesheet\' type=\'text/css\' href=\'/css/carroaluguel/lp-locadoras/tooltipster.bundle.min.css?rand=1473076156\'/><script src=\'/js/carroaluguel/jquery-1.11.1.min.js\' type=\'text/javascript\'></script><script src=\'/js/vendor/custom.modernizr.js\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/jquery.waitforimages.min.js\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/jquery-ui.min.js\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/cotacao/picker.js\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/cotacao/picker.date.js\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/cotacao/picker.time.js\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/cotacao/legacy.js\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/cotacao/pt_BR.js\' type=\'text/javascript\'></script><script src=\'/foundation-5/js/foundation.min.js\' type=\'text/javascript\'></script><script src=\'/foundation-5/js/foundation/foundation.orbit.min.js\' type=\'text/javascript\'></script><script src=\'/js/validator.js\' type=\'text/javascript\'></script><script src=\'/js/jquery.autocomplete.js\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/autocomplete.min.js\' type=\'text/javascript\'></script><script src=\'/js/vendor/zepto.min.js\' type=\'text/javascript\'></script><script src=\'/js/cufon-yui.js\' type=\'text/javascript\'></script><script src=\'/js/Angelina_400.font.js\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/jquery.validationEngine-pt_BR.min.js\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/jquery.validationEngine.min.js\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/jquery.maskedinput.min.js\' type=\'text/javascript\'></script><script src=\'https://maps.googleapis.com/maps/api/js?key=AIzaSyCshlchUO4g8oz1XKfXDhqzFs9cOWVUX7s\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/funilreservas/tooltipster.bundle.min.js\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/funilreservas/locadoras.js?rand=235316588\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/funilreservas/locadoras_loja.js?rand=1913666853\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/funilreservas/sweetalert2.js\' type=\'text/javascript\'></script><script src=\'https://d335luupugsy2.cloudfront.net/js/integration/stable/rd-js-integration.min.js\' type=\'text/javascript\'></script><script src=\'/js/carroaluguel/funilreservas/bioep.js?rand=54602503\' type=\'text/javascript\'></script><script type=\"text/javascript\">$(\"#newsletter-ok\").click(function(){if($(\"#email\").val() == \"\"){alert(\"O campo e-mail deve ser preenchido!\");return false;}var data = {};data[\"news-email\"] = $(\"#email\").val();$.ajax({type: \"POST\",url: \"https://www.carroaluguel.com/newsletter.php\",data: data,success: function(r){var data_array = [{ name: \'email\', value: $(\"#email\").val() },{ name: \'identificador\', value: \'Landing Page Locadora Loja\' },{ name: \'token_rdstation\', value: \'97905d7f62030465da2035e9a64ee4b9\' },{ name: \'nome\', value: \'\' }];RdIntegration.post(data_array, function () { alert(\'E-mail cadastrado com sucesso!\'); });$(\"#email\").val(\"\");}});});</script><link href=\'https://fonts.googleapis.com/css?family=Viga\' rel=\'stylesheet\' type=\'text/css\' /><!-- http://www.LiveZilla.net Tracking Code --><div id=\"livezilla_tracking\" style=\"display:none\"></div><script language=\"JavaScript\" type=\"text/javascript\">var script = document.createElement(\"script\");script.type=\"text/javascript\";var src = \"https://www.carroaluguel.com/suporte/server.php?request=track&output=jcrpt&nse=\"+Math.random();setTimeout(\"script.src=src;document.getElementById(\'livezilla_tracking\').appendChild(script)\",1);</script><!-- http://www.LiveZilla.net Tracking Code --><!-- Google Code for Home Remarketing List --><script type=\"text/javascript\">/* <![CDATA[ */var google_conversion_id = 1049369987;var google_conversion_language = \"en\";var google_conversion_format = \"3\";var google_conversion_color = \"ffffff\";var google_conversion_label = \"iViFCL3g-AIQg7uw9AM\";var google_conversion_value = 0;/* ]]> */</script><script type=\"text/javascript\" src=\"https://www.googleadservices.com/pagead/conversion.js\"></script><noscript><div style=\"display:inline;\"><img height=\"1\" width=\"1\" style=\"border-style:none;\" alt=\"\" src=\"https://www.googleadservices.com/pagead/conversion/1049369987/?label=iViFCL3g-AIQg7uw9AM&amp;guid=ON&amp;script=0\"/></div></noscript></body><script type=\"text/javascript\">bioEp.init();$(\"#bio_ep_close\").click(function(){bioEp.hidePopup();});$(\'.botaoBlack\').click(function(){event.preventDefault();if($(\"#black_email\").val() == \"\"){swal(\"O campo e-mail deve ser preenchido!\");return false;}var data = {};data[\"news-email\"] = $(\"#black_email\").val();$.ajax({type: \"POST\",url: \"https://www.carroaluguel.com/newsletter.php\",data: data,success: function(r){var data_array = [{ name: \'email\', value: $(\"#black_email\").val() },{ name: \'identificador\', value: \'Exit-PopUP\' },{ name: \'token_rdstation\', value: \'97905d7f62030465da2035e9a64ee4b9\' },{ name: \'nome\', value: \'\' }];RdIntegration.post(data_array, function () { swal(\'E-mail cadastrado com sucesso!\'); });$(\"#black_email\").val(\"\");bioEp.hidePopup();}});});$(\'#btnEnviar\').click(function(){var valorEnviar = $(\'#txtEnderecoPartida\').val();$(\'#hdnOrigem\').val(valorEnviar);if ($(\'#hdnOrigem\').val() != \'\'){$(\'#texto_origem\').html(valorEnviar);}});function limpador_texto_cidade() {$(\"#retirar_cidade\").attr(\"readonly\", false);$(\"#retirar_cidade\").val(\'\');$(\'#retirar_cidade-cid_principal\').remove();$(\'#retirar_cidade-ref_principal\').remove();$(\'#retirar_cidade-val_principal\').remove();}$(\'#retirar_cidade\').click(function() {$(\"#retirar_cidade\").attr(\"readonly\", false);$(\"#retirar_cidade\").val(\'\');$(\'#retirar_cidade-cid_principal\').remove();$(\'#retirar_cidade-ref_principal\').remove();$(\'#retirar_cidade-val_principal\').remove();});function limpador_texto_cidade_float() {$(\"#retirar_cidade_float\").attr(\"readonly\", false);$(\"#retirar_cidade_float\").val(\'\');$(\'#retirar_cidade-cid_principal_float\').remove();$(\'#retirar_cidade-ref_principal_float\').remove();$(\'#retirar_cidade-val_principal_float\').remove();}$(\'#retirar_cidade_float\').click(function() {$(\"#retirar_cidade_float\").attr(\"readonly\", false);$(\"#retirar_cidade_float\").val(\'\');$(\'#retirar_cidade-cid_principal_float\').remove();$(\'#retirar_cidade-ref_principal_float\').remove();$(\'#retirar_cidade-val_principal_float\').remove();});function limpador_retira_cidade_mbl_ne() {$(\"#mbl_retirar_cidade\").attr(\"readonly\", false);$(\"#mbl_retirar_cidade\").val(\'\');$(\'#retirar_cidade-cid_mbl\').remove();$(\'#retirar_cidade-ref_mbl\').remove();$(\'#retirar_cidade-val_mbl\').remove();}$(\'#mbl_retirar_cidade\').click(function() {$(\"#mbl_retirar_cidade\").attr(\"readonly\", false);$(\"#mbl_retirar_cidade\").val(\'\');$(\'#retirar_cidade-cid_mbl\').remove();$(\'#retirar_cidade-ref_mbl\').remove();$(\'#retirar_cidade-val_mbl\').remove();});function limpador_retira_cidade_mbl_ne_float() {$(\"#retirar_cidade_float_mbl\").attr(\"readonly\", false);$(\"#retirar_cidade_float_mbl\").val(\'\');$(\'#retirar_cidade-cid_float_mbl\').remove();$(\'#retirar_cidade-ref_float_mbl\').remove();$(\'#retirar_cidade-val_float_mbl\').remove();}$(\'#retirar_cidade_float_mbl\').click(function() {$(\"#retirar_cidade_float_mbl\").attr(\"readonly\", false);$(\"#retirar_cidade_float_mbl\").val(\'\');$(\'#retirar_cidade-cid_float_mbl\').remove();$(\'#retirar_cidade-ref_float_mbl\').remove();$(\'#retirar_cidade-val_float_mbl\').remove();});$(document).ready(function() {var enderecoPartida = $(\'#hdnDestinoLatiLong\').val();var enderecoChegada = $(\'#hdnDestinoLatiLong\').val();var request = {origin: enderecoPartida,destination: enderecoChegada,travelMode: google.maps.TravelMode.DRIVING};directionsService.route(request, function (result, status) {if (status == google.maps.DirectionsStatus.OK) {directionsDisplay.setDirections(result);}});var enderecoPartida_mbl = $(\'#hdnDestinoLatiLong\').val();var enderecoChegada_mbl = $(\'#hdnDestinoLatiLong\').val();var request = {origin: enderecoPartida_mbl,destination: enderecoChegada_mbl,travelMode: google.maps.TravelMode.DRIVING};directionsService_mbl.route(request, function (result, status) {if (status == google.maps.DirectionsStatus.OK) {directionsDisplay_mbl.setDirections(result);}});initialize();var tamanho_h1_cima = $(\'#tamanho_h1_cima\').val();var mbl_check = $(\'#mbl_check\').val();if (mbl_check == 1){if (tamanho_h1_cima > 45){$(\'.mbl_h1_locadora_loja_baixo\').addClass(\'arruma_tamanho_h2_grandes\');$(\'.mbl_fundo_sprite\').addClass(\'arruma_posicao_banner_mbl\');}}else{if (tamanho_h1_cima > 99){$(\'.h1_locadora_loja\').addClass(\'arruma_tamanho_h1_grandes\');$(\'.mbl_h1_locadora_loja_baixo\').addClass(\'arruma_tamanho_h2_grandes\');}}});</script>