0%
<div class="vce-row-container"><div class="vce-row vce-row--col-gap-30 vce-row-columns--top vce-row-content--top" id="el-b8a89241" data-vce-do-apply="all el-b8a89241"><div class="vce-row-content" data-vce-element-content="true"><div class="vce-col vce-col--md-auto vce-col--xs-1 vce-col--xs-last vce-col--xs-first vce-col--sm-last vce-col--sm-first vce-col--md-last vce-col--lg-last vce-col--xl-last vce-col--md-first vce-col--lg-first vce-col--xl-first" id="el-2ccd45fd"><div class="vce-col-inner" data-vce-do-apply="border margin background  el-2ccd45fd"><div class="vce-col-content" data-vce-element-content="true" data-vce-do-apply="padding el-2ccd45fd"><div class="vce-text-block"><div class="vce-text-block-wrapper vce" id="el-a11b99c0" data-vce-do-apply="all el-a11b99c0"><p>&nbsp;</p><p>&nbsp;</p><p><div  id='HomeSobreNosotros'  class="vc_row wpb_row vc_row-fluid  ">
	<div class="vc_span12 wpb_column vc_column_container "><div class="vc_column-inner ">
		<div class="wpb_wrapper">
			<h2 style="text-align: center;font-family:Lato;font-weight:400;font-style:normal" class="vc_custom_heading Titulo" >SOBRE NOSOTROS</h2>
			<div class="tab-holder rd_tabs mc_rd_tabs horizontal rd_tab_1   rd_vtab_left" style="margin-top:px; margin-bottom:px;"><div class="tab-hold tabs-wrapper"><ul id="tabs" class="tabs"><li class="tabli"><a href="#tab-4ac806ab-1908-10">Hiades</a></li><li class="tabli"><a href="#tab-48e819ee-25ee-6">Servicios</a></li><li class="tabli"><a href="#tab-1523616805688-2-8">Historia</a></li></ul>
<div class='tab-box tabs-container'>
			
			<div id="tab-4ac806ab-1908-10" class=" vc_clearfix tab_content">
				
	<div class="wpb_text_column wpb_content_element  usascroll " >
		<div class="wpb_wrapper" id="ct_bjyv9dijftoan20dakt2">
			<p style="text-align: center;"><strong>La tecnología al servicio de su compañía</strong></p>
<p>HIADES BUSINESS PATTERNS es una empresa tecnológica con presencia en Europa e Iberoamérica especializada en el desarrollo y gestión de negocios utilizando herramientas de Inteligencia de Negocio y con soporte en cualquier plataforma tecnológica y en todos los sistemas operativos.</p>
<p>Esta empresa ha recibido diversos premios y reconocimientos en materia tecnológica y es referente en Canarias en tecnología aplicada a los negocios, en inteligencia de negocio (Business Intelligence) y en desarrollo de aplicaciones móviles y videojuegos.</p>
<p>Hiades tiene presencia en Canarias y España así como en Iberoamérica donde está cerrando grandes acuerdos de negocio para su expansión internacional.</p>
<p>Actualmente Hiades, además de su sede principal en Canarias, dispone de Sede en Asunción, Paraguay, desde la que comercializamos los productos y servicios en Latinoamérica.</p>
<p>Las principales líneas de la compañía son:</p>
<ul>
<li><strong>Transformación digital de empresas:</strong> La revolución digital actual está produciendo cambios profundos en empresas y profesionales. Estos cambios alcanzan todas las áreas de las organizaciones y todos los sectores de la economía. El actual escenario, derivado de los avances tecnológicos, está generando, además, nuevos hábitos en los clientes y los modelos de negocio; así como también han aparecido competidores que han roto totalmente el status quo.</li>
</ul>
<ul>
<li>Para la <strong>transformación digital</strong> nos apoyamos en el <strong>desarrollo de programas a medida</strong>, herramientas para la toma de decisiones empresariales: <strong>Cuadros de Mando</strong> que permiten comprender, analizar, y tomar decisiones efectivas, rápidas y fiables en un entorno virtual sencillo, intuitivo y personalizable; e incluso desarrollo de <strong>aplicaciones móviles</strong> que permiten a las empresas mejoren y faciliten el contacto con sus clientes, así como la interacción con redes sociales y campañas de marketing; y búsqueda de <strong>financiación</strong> para la ejecución de los proyectos.</li>
</ul>
<ul>
<li><strong>Análisis de tecnológico y consultoría tecnológica</strong>: Análisis de Innovación Tecnológica, Estudios de sectoriales para la aplicación de mejores prácticas tecnlógicas para la mejora de la productividad, Planes de creación de nuevas líneas de negocio tecnológicas.</li>
</ul>
<ul>
<li><strong>Mejora de procesos:</strong> Utilización de la tecnología para la mejora de los procesos internos de las empresas con desarrollo de <strong>programas a medida</strong> o licenciando existentes.</li>
</ul>
<ul>
<li><strong>Inversión capital semilla:</strong> Inversión en startups para ayudar en sus etapas iniciales, aportando capital semilla, mentorización, gestión y seguimiento de proyectos así como su desarrollo.</li>
</ul>

		</div> 
	</div> 
			</div> 
			<div id="tab-48e819ee-25ee-6" class=" vc_clearfix tab_content">
				<div class="vc_row wpb_row vc_inner vc_row-fluid"><div class="Listado wpb_column vc_column_container vc_span4"><div class="vc_column-inner  "><div class="wpb_wrapper">
<!-- lists --><div class="rd_list_1_alt rd_list_left"><style type='text/css'> @font-face{font-family: 'wb'; src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot'); src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot?#iefix') format('embedded-opentype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.woff') format('woff'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.ttf') format('truetype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.svg#oi') format('svg'); font-weight: normal; font-style: normal;}#rand_msn8yadinzghq1gqdwlg .wb-uniF479:before{font-family: 'wb'; font-weight: normal; font-style: normal;}#rand_msn8yadinzghq1gqdwlg .wb-uniF479:before{content: "\f479";}</style>
<style type="text/css" >.rd_list_1 .list_item_ctn { border-color:#ecf0f1}.rd_list_1 #rand_msn8yadinzghq1gqdwlg .list_icn i,.rd_list_1_alt #rand_msn8yadinzghq1gqdwlg .list_icn i{color:#288bd0;}.rd_list_2 #rand_msn8yadinzghq1gqdwlg:after{background:#575757;}.rd_list_2 #rand_msn8yadinzghq1gqdwlg .list_icn i{color:#288bd0;}.rd_list_3 #rand_msn8yadinzghq1gqdwlg .list_icn,.rd_list_5 #rand_msn8yadinzghq1gqdwlg .list_icn,.rd_list_6 #rand_msn8yadinzghq1gqdwlg .list_icn{background:#288bd0;}.rd_list_4 #rand_msn8yadinzghq1gqdwlg{background:#288bd0;}#rand_msn8yadinzghq1gqdwlg h3{color:#333333;}#rand_msn8yadinzghq1gqdwlg p{color:#575757;}.rd_list_7 #rand_msn8yadinzghq1gqdwlg .list_icn{color:#288bd0;}</style><div class="list_item_ctn" id="rand_msn8yadinzghq1gqdwlg"><div class="list_icn"><i class="wb-uniF479"></i></div><div class="list_desc"><h3>Consultoría Tecnológica.</h3></div></div><style type='text/css'> @font-face{font-family: 'wb'; src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot'); src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot?#iefix') format('embedded-opentype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.woff') format('woff'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.ttf') format('truetype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.svg#oi') format('svg'); font-weight: normal; font-style: normal;}#rand_w7zrgbca4doabdhspcw5 .wb-uniF479:before{font-family: 'wb'; font-weight: normal; font-style: normal;}#rand_w7zrgbca4doabdhspcw5 .wb-uniF479:before{content: "\f479";}</style>
<style type="text/css" >.rd_list_1 .list_item_ctn { border-color:#ecf0f1}.rd_list_1 #rand_w7zrgbca4doabdhspcw5 .list_icn i,.rd_list_1_alt #rand_w7zrgbca4doabdhspcw5 .list_icn i{color:#288bd0;}.rd_list_2 #rand_w7zrgbca4doabdhspcw5:after{background:#575757;}.rd_list_2 #rand_w7zrgbca4doabdhspcw5 .list_icn i{color:#288bd0;}.rd_list_3 #rand_w7zrgbca4doabdhspcw5 .list_icn,.rd_list_5 #rand_w7zrgbca4doabdhspcw5 .list_icn,.rd_list_6 #rand_w7zrgbca4doabdhspcw5 .list_icn{background:#288bd0;}.rd_list_4 #rand_w7zrgbca4doabdhspcw5{background:#288bd0;}#rand_w7zrgbca4doabdhspcw5 h3{color:#333333;}#rand_w7zrgbca4doabdhspcw5 p{color:#575757;}.rd_list_7 #rand_w7zrgbca4doabdhspcw5 .list_icn{color:#288bd0;}</style><div class="list_item_ctn" id="rand_w7zrgbca4doabdhspcw5"><div class="list_icn"><i class="wb-uniF479"></i></div><div class="list_desc"><h3>Desarrollo a medida de aplicaciones.</h3></div></div><style type='text/css'> @font-face{font-family: 'wb'; src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot'); src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot?#iefix') format('embedded-opentype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.woff') format('woff'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.ttf') format('truetype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.svg#oi') format('svg'); font-weight: normal; font-style: normal;}#rand_zzale6jtf3jpkwbgmlgl .wb-uniF479:before{font-family: 'wb'; font-weight: normal; font-style: normal;}#rand_zzale6jtf3jpkwbgmlgl .wb-uniF479:before{content: "\f479";}</style>
<style type="text/css" >.rd_list_1 .list_item_ctn { border-color:#ecf0f1}.rd_list_1 #rand_zzale6jtf3jpkwbgmlgl .list_icn i,.rd_list_1_alt #rand_zzale6jtf3jpkwbgmlgl .list_icn i{color:#288bd0;}.rd_list_2 #rand_zzale6jtf3jpkwbgmlgl:after{background:#575757;}.rd_list_2 #rand_zzale6jtf3jpkwbgmlgl .list_icn i{color:#288bd0;}.rd_list_3 #rand_zzale6jtf3jpkwbgmlgl .list_icn,.rd_list_5 #rand_zzale6jtf3jpkwbgmlgl .list_icn,.rd_list_6 #rand_zzale6jtf3jpkwbgmlgl .list_icn{background:#288bd0;}.rd_list_4 #rand_zzale6jtf3jpkwbgmlgl{background:#288bd0;}#rand_zzale6jtf3jpkwbgmlgl h3{color:#333333;}#rand_zzale6jtf3jpkwbgmlgl p{color:#575757;}.rd_list_7 #rand_zzale6jtf3jpkwbgmlgl .list_icn{color:#288bd0;}</style><div class="list_item_ctn" id="rand_zzale6jtf3jpkwbgmlgl"><div class="list_icn"><i class="wb-uniF479"></i></div><div class="list_desc"><h3>Desarrollo de Apps.</h3></div></div></div>

<!-- lists END-->
</div></div></div><div class="Listado wpb_column vc_column_container vc_span4"><div class="vc_column-inner  "><div class="wpb_wrapper">
<!-- lists --><div class="rd_list_1_alt rd_list_left"><style type='text/css'> @font-face{font-family: 'wb'; src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot'); src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot?#iefix') format('embedded-opentype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.woff') format('woff'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.ttf') format('truetype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.svg#oi') format('svg'); font-weight: normal; font-style: normal;}#rand_dyn91q9qqx8d90r17abk .wb-uniF479:before{font-family: 'wb'; font-weight: normal; font-style: normal;}#rand_dyn91q9qqx8d90r17abk .wb-uniF479:before{content: "\f479";}</style>
<style type="text/css" >.rd_list_1 .list_item_ctn { border-color:#ecf0f1}.rd_list_1 #rand_dyn91q9qqx8d90r17abk .list_icn i,.rd_list_1_alt #rand_dyn91q9qqx8d90r17abk .list_icn i{color:#288bd0;}.rd_list_2 #rand_dyn91q9qqx8d90r17abk:after{background:#575757;}.rd_list_2 #rand_dyn91q9qqx8d90r17abk .list_icn i{color:#288bd0;}.rd_list_3 #rand_dyn91q9qqx8d90r17abk .list_icn,.rd_list_5 #rand_dyn91q9qqx8d90r17abk .list_icn,.rd_list_6 #rand_dyn91q9qqx8d90r17abk .list_icn{background:#288bd0;}.rd_list_4 #rand_dyn91q9qqx8d90r17abk{background:#288bd0;}#rand_dyn91q9qqx8d90r17abk h3{color:#333333;}#rand_dyn91q9qqx8d90r17abk p{color:#575757;}.rd_list_7 #rand_dyn91q9qqx8d90r17abk .list_icn{color:#288bd0;}</style><div class="list_item_ctn" id="rand_dyn91q9qqx8d90r17abk"><div class="list_icn"><i class="wb-uniF479"></i></div><div class="list_desc"><h3>Cuadros de Mando.</h3></div></div><style type='text/css'> @font-face{font-family: 'wb'; src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot'); src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot?#iefix') format('embedded-opentype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.woff') format('woff'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.ttf') format('truetype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.svg#oi') format('svg'); font-weight: normal; font-style: normal;}#rand_xrhtrtmsnown09ffrqhd .wb-uniF479:before{font-family: 'wb'; font-weight: normal; font-style: normal;}#rand_xrhtrtmsnown09ffrqhd .wb-uniF479:before{content: "\f479";}</style>
<style type="text/css" >.rd_list_1 .list_item_ctn { border-color:#ecf0f1}.rd_list_1 #rand_xrhtrtmsnown09ffrqhd .list_icn i,.rd_list_1_alt #rand_xrhtrtmsnown09ffrqhd .list_icn i{color:#288bd0;}.rd_list_2 #rand_xrhtrtmsnown09ffrqhd:after{background:#575757;}.rd_list_2 #rand_xrhtrtmsnown09ffrqhd .list_icn i{color:#288bd0;}.rd_list_3 #rand_xrhtrtmsnown09ffrqhd .list_icn,.rd_list_5 #rand_xrhtrtmsnown09ffrqhd .list_icn,.rd_list_6 #rand_xrhtrtmsnown09ffrqhd .list_icn{background:#288bd0;}.rd_list_4 #rand_xrhtrtmsnown09ffrqhd{background:#288bd0;}#rand_xrhtrtmsnown09ffrqhd h3{color:#333333;}#rand_xrhtrtmsnown09ffrqhd p{color:#575757;}.rd_list_7 #rand_xrhtrtmsnown09ffrqhd .list_icn{color:#288bd0;}</style><div class="list_item_ctn" id="rand_xrhtrtmsnown09ffrqhd"><div class="list_icn"><i class="wb-uniF479"></i></div><div class="list_desc"><h3>Análisis de proyectos en pre-aceleración.</h3></div></div><style type='text/css'> @font-face{font-family: 'wb'; src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot'); src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot?#iefix') format('embedded-opentype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.woff') format('woff'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.ttf') format('truetype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.svg#oi') format('svg'); font-weight: normal; font-style: normal;}#rand_wnxdhpytf92i4bt00sxf .wb-uniF479:before{font-family: 'wb'; font-weight: normal; font-style: normal;}#rand_wnxdhpytf92i4bt00sxf .wb-uniF479:before{content: "\f479";}</style>
<style type="text/css" >.rd_list_1 .list_item_ctn { border-color:#ecf0f1}.rd_list_1 #rand_wnxdhpytf92i4bt00sxf .list_icn i,.rd_list_1_alt #rand_wnxdhpytf92i4bt00sxf .list_icn i{color:#288bd0;}.rd_list_2 #rand_wnxdhpytf92i4bt00sxf:after{background:#575757;}.rd_list_2 #rand_wnxdhpytf92i4bt00sxf .list_icn i{color:#288bd0;}.rd_list_3 #rand_wnxdhpytf92i4bt00sxf .list_icn,.rd_list_5 #rand_wnxdhpytf92i4bt00sxf .list_icn,.rd_list_6 #rand_wnxdhpytf92i4bt00sxf .list_icn{background:#288bd0;}.rd_list_4 #rand_wnxdhpytf92i4bt00sxf{background:#288bd0;}#rand_wnxdhpytf92i4bt00sxf h3{color:#333333;}#rand_wnxdhpytf92i4bt00sxf p{color:#575757;}.rd_list_7 #rand_wnxdhpytf92i4bt00sxf .list_icn{color:#288bd0;}</style><div class="list_item_ctn" id="rand_wnxdhpytf92i4bt00sxf"><div class="list_icn"><i class="wb-uniF479"></i></div><div class="list_desc"><h3>Desarrollo de proyectos de innovación.</h3></div></div></div>

<!-- lists END-->
</div></div></div><div class="Listado wpb_column vc_column_container vc_span4"><div class="vc_column-inner  "><div class="wpb_wrapper">
<!-- lists --><div class="rd_list_1_alt rd_list_left"><style type='text/css'> @font-face{font-family: 'wb'; src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot'); src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot?#iefix') format('embedded-opentype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.woff') format('woff'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.ttf') format('truetype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.svg#oi') format('svg'); font-weight: normal; font-style: normal;}#rand_mslhtffel6m4840pgvy4 .wb-uniF479:before{font-family: 'wb'; font-weight: normal; font-style: normal;}#rand_mslhtffel6m4840pgvy4 .wb-uniF479:before{content: "\f479";}</style>
<style type="text/css" >.rd_list_1 .list_item_ctn { border-color:#ecf0f1}.rd_list_1 #rand_mslhtffel6m4840pgvy4 .list_icn i,.rd_list_1_alt #rand_mslhtffel6m4840pgvy4 .list_icn i{color:#288bd0;}.rd_list_2 #rand_mslhtffel6m4840pgvy4:after{background:#575757;}.rd_list_2 #rand_mslhtffel6m4840pgvy4 .list_icn i{color:#288bd0;}.rd_list_3 #rand_mslhtffel6m4840pgvy4 .list_icn,.rd_list_5 #rand_mslhtffel6m4840pgvy4 .list_icn,.rd_list_6 #rand_mslhtffel6m4840pgvy4 .list_icn{background:#288bd0;}.rd_list_4 #rand_mslhtffel6m4840pgvy4{background:#288bd0;}#rand_mslhtffel6m4840pgvy4 h3{color:#333333;}#rand_mslhtffel6m4840pgvy4 p{color:#575757;}.rd_list_7 #rand_mslhtffel6m4840pgvy4 .list_icn{color:#288bd0;}</style><div class="list_item_ctn" id="rand_mslhtffel6m4840pgvy4"><div class="list_icn"><i class="wb-uniF479"></i></div><div class="list_desc"><h3>Búsqueda de financiación para proyectos de innovación.</h3></div></div><style type='text/css'> @font-face{font-family: 'wb'; src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot'); src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot?#iefix') format('embedded-opentype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.woff') format('woff'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.ttf') format('truetype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.svg#oi') format('svg'); font-weight: normal; font-style: normal;}#rand_5lyfob0nloo24wv5fns8 .wb-uniF479:before{font-family: 'wb'; font-weight: normal; font-style: normal;}#rand_5lyfob0nloo24wv5fns8 .wb-uniF479:before{content: "\f479";}</style>
<style type="text/css" >.rd_list_1 .list_item_ctn { border-color:#ecf0f1}.rd_list_1 #rand_5lyfob0nloo24wv5fns8 .list_icn i,.rd_list_1_alt #rand_5lyfob0nloo24wv5fns8 .list_icn i{color:#288bd0;}.rd_list_2 #rand_5lyfob0nloo24wv5fns8:after{background:#575757;}.rd_list_2 #rand_5lyfob0nloo24wv5fns8 .list_icn i{color:#288bd0;}.rd_list_3 #rand_5lyfob0nloo24wv5fns8 .list_icn,.rd_list_5 #rand_5lyfob0nloo24wv5fns8 .list_icn,.rd_list_6 #rand_5lyfob0nloo24wv5fns8 .list_icn{background:#288bd0;}.rd_list_4 #rand_5lyfob0nloo24wv5fns8{background:#288bd0;}#rand_5lyfob0nloo24wv5fns8 h3{color:#333333;}#rand_5lyfob0nloo24wv5fns8 p{color:#575757;}.rd_list_7 #rand_5lyfob0nloo24wv5fns8 .list_icn{color:#288bd0;}</style><div class="list_item_ctn" id="rand_5lyfob0nloo24wv5fns8"><div class="list_icn"><i class="wb-uniF479"></i></div><div class="list_desc"><h3>Productos específicos en Sector de la Automoción.</h3></div></div><style type='text/css'> @font-face{font-family: 'wb'; src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot'); src:url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.eot?#iefix') format('embedded-opentype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.woff') format('woff'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.ttf') format('truetype'), url('http://hiades.es/wp-content/themes/thefox/includes/4k-icons/icons/4k-icons-pack05/icons/fonts/wb.svg#oi') format('svg'); font-weight: normal; font-style: normal;}#rand_ntfo7z3kg385khl76a78 .wb-uniF479:before{font-family: 'wb'; font-weight: normal; font-style: normal;}#rand_ntfo7z3kg385khl76a78 .wb-uniF479:before{content: "\f479";}</style>
<style type="text/css" >.rd_list_1 .list_item_ctn { border-color:#ecf0f1}.rd_list_1 #rand_ntfo7z3kg385khl76a78 .list_icn i,.rd_list_1_alt #rand_ntfo7z3kg385khl76a78 .list_icn i{color:#288bd0;}.rd_list_2 #rand_ntfo7z3kg385khl76a78:after{background:#575757;}.rd_list_2 #rand_ntfo7z3kg385khl76a78 .list_icn i{color:#288bd0;}.rd_list_3 #rand_ntfo7z3kg385khl76a78 .list_icn,.rd_list_5 #rand_ntfo7z3kg385khl76a78 .list_icn,.rd_list_6 #rand_ntfo7z3kg385khl76a78 .list_icn{background:#288bd0;}.rd_list_4 #rand_ntfo7z3kg385khl76a78{background:#288bd0;}#rand_ntfo7z3kg385khl76a78 h3{color:#333333;}#rand_ntfo7z3kg385khl76a78 p{color:#575757;}.rd_list_7 #rand_ntfo7z3kg385khl76a78 .list_icn{color:#288bd0;}</style><div class="list_item_ctn" id="rand_ntfo7z3kg385khl76a78"><div class="list_icn"><i class="wb-uniF479"></i></div><div class="list_desc"><h3>Productos específicos en Sector Portuario.</h3></div></div></div>

<!-- lists END-->
</div></div></div></div>
			</div> 
			<div id="tab-1523616805688-2-8" class=" vc_clearfix tab_content">
				<div class="vc_row wpb_row vc_inner vc_row-fluid usascroll"><div class="wpb_column vc_column_container vc_span12"><div class="vc_column-inner  "><div class="wpb_wrapper"><h2 style="text-align: center;font-family:Lato;font-weight:400;font-style:normal" class="vc_custom_heading Titulo" >Premios e Historia</h2></div></div></div><div class="wpb_column vc_column_container vc_span12"><div class="vc_column-inner  "><div class="wpb_wrapper">
	<div class="wpb_text_column wpb_content_element  vc_custom_1525768874484 " >
		<div class="wpb_wrapper" id="ct_26maqfkenv75rix2rz9s">
			<p><span class="TituloPremios"><strong>GRUPO HIADES</strong></span></p>
<p>Los resultados del desarrollo de consultoría tecnológica ha sido avalada por los siguientes logros:</p>

		</div> 
	</div> </div></div></div><div class="wpb_column vc_column_container vc_span6"><div class="vc_column-inner  "><div class="wpb_wrapper">
	<div class="wpb_text_column wpb_content_element  " >
		<div class="wpb_wrapper" id="ct_8lj4d5in8rtc5noa83x6">
			<p><strong class="TituloPremios">AÑO 2010</strong></p>
<ul>
<li>Primer Premio TF Innova 2010 Proyectos de Empresas de Base Tecnológica e Intensivas en Conocimiento del Cabildo de Tenerife.</li>
</ul>
<p><span class="TextoPremios">&nbsp;</span></p>

		</div> 
	</div> 
	<div class="wpb_text_column wpb_content_element  " >
		<div class="wpb_wrapper" id="ct_r5dkogb0k94rg6dm6lk6">
			<p><span class="TituloPremios"><strong>AÑO 2011</strong></span></p>
<ul>
<li>Segundo Premio TF Innova 2011 Proyectos de Empresas de Base Tecnológica e Intensivas en Conocimiento del Cabildo de Tenerife.</li>
<li>Segundo Premio Fyde Cajacanarias 2011 en la categoría Emprendedores por el proyecto Tropical Games.</li>
<li>Mención Honorífica Premio Psicofundación 2011 por el Proyecto Eudora Human Capital.</li>
<li>Finalista II Foro Tenerife Invierte 2011 por el proyecto Hiades Business Patterns.</li>
<li>Finalista II Foro Tenerife Invierte 2011 por el proyecto Eheide Mobility.</li>
<li>Finalista XVI Premio Fyde Cajacanarias 2011 en la categoría Proyecto Empresarial por Eudora Human Capital.</li>
</ul>
<p><span class="TextoPremios">&nbsp;</span></p>

		</div> 
	</div> 
	<div class="wpb_text_column wpb_content_element  " >
		<div class="wpb_wrapper" id="ct_gtqnx33w5zdh9ssjeba8">
			<p><strong class="TituloPremios">AÑO 2012</strong><span class="TextoPremios"><br /></span></p>
<ul>
<li>Finalista I Foro Disa Emprende 2012 por el proyecto Hiades Business Patterns.</li>
<li>Finalista I Foro Disa Emprende 2012 por el proyecto Tropical Games Studio.</li>
<li>Finalista La Caixa Emprendedor XXI 2012 por el proyecto Hiades Business Patterns.</li>
<li>Finalista Premio Emprendedor Canario 2012 Confederación Canaria de Empresarios a Airam Rodríguez Rodríguez.</li>
<li>Top Ten de los mejores videojuegos europeos 2012 StartUp2.0.eu por Rapanui Adventures por votación popular.</li>
</ul>
<p><span class="TextoPremios">&nbsp;</span></p>

		</div> 
	</div> </div></div></div><div class="wpb_column vc_column_container vc_span5"><div class="vc_column-inner  "><div class="wpb_wrapper">
	<div class="wpb_text_column wpb_content_element  " >
		<div class="wpb_wrapper" id="ct_9sdbezcaydbw0dt8k116">
			<p><strong class="TituloPremios">AÑO 2013</strong></p>
<ul>
<li>Primer Premio Fyde Cajacanarias 2013 en la categoría Emprendedores por el proyecto Canarias Cycling. – Partner Tecnológico</li>
<li>Finalista IV Foro Tenerife Invierte 2013 por el proyecto Tarjeteo – Partner Tecnológico.</li>
</ul>
<p><span class="TextoPremios">&nbsp;</span></p>

		</div> 
	</div> 
	<div class="wpb_text_column wpb_content_element  " >
		<div class="wpb_wrapper" id="ct_pjvydjdemrdxe21zo654">
			<p><strong class="TituloPremios">AÑO 2014</strong></p>
<ul>
<li>Mención de Honor en la categoría m-Enternaiment &amp; Lifestyle en el WSA (World Summit Award) – Mobile Content por la app/juego UR Meter.</li>
</ul>

		</div> 
	</div> 
	<div class="wpb_text_column wpb_content_element  " >
		<div class="wpb_wrapper" id="ct_n0xb58zv4seol4vg31el">
			<p><strong class="TituloPremios">AÑO 2015</strong></p>
<ul>
<li>I Concurso de Ideas Emprendedoras en Canarias de las Cámaras de Comercio de Canarias por el proyecto Maravitia – Partner Tecnológico y Mentorización.</li>
<li>Finalista II Concurso de Ideas Emprendedoras de la Cámara de España por el proyecto Maravitia - Partner Tecnológico y Mentorización.</li>
<li>Mención Honorífica - Mejor Startup - TF Invierte Gold Edition por el proyecto Girl’s Wardrobe – Partner Tecnológico y Mentorización.</li>
<li>Premio Sales Day – Olympo Boxes – Cámara de Comercio de Tenerife – por el proyecto Amura.</li>
</ul>

		</div> 
	</div> 
	<div class="wpb_text_column wpb_content_element  " >
		<div class="wpb_wrapper" id="ct_jp9pptpjnwsekryokmbk">
			<p><strong class="TituloPremios">AÑO 2016</strong></p>
<ul>
<li>I Premio Heineken 2016 por la innovación en el sector Gastronómico y Hostelero en el marco del I Concurso Internacional #Foodture de Proyectos Innovadores por el proyecto Smartwaiter – Partner Tecnológico.</li>
<li>Premio Concurso de Ideas para la Integración de Agricultura y Turismo 2016 por el proyecto Maravitia – Partner Tecnológico y Mentorización.</li>
</ul>

		</div> 
	</div> </div></div></div></div>
			</div> </div></div></div>
		</div> </div>
	</div> 
</div><div  id='HomeTrabajo'  class="vc_row wpb_row vc_row-fluid vc_custom_1524218068512  ">
	<div class="vc_span12 wpb_column vc_column_container "><div class="vc_column-inner ">
		<div class="wpb_wrapper">
			<h2 style="text-align: center;font-family:Lato;font-weight:400;font-style:normal" class="vc_custom_heading Titulo" >NUESTRO TRABAJO</h2>
	<div class="wpb_text_column wpb_content_element  TituloCita " >
		<div class="wpb_wrapper" id="ct_wjs2qkz2sdzsrnhamgjk">
			<p style="text-align: center;">Ir juntos es comenzar. Mantenerse juntos es progresar.<br />Trabajar juntos es triunfar.</p>

		</div> 
	</div> <script>jQuery.noConflict(); var $ = jQuery; </script><div id="randomtryc0f38th66w6rte2ei_port" class="portfolio"><style type="text/css" >#randomtryc0f38th66w6rte2ei_port .filter_type_7 #options .selected a,#randomtryc0f38th66w6rte2ei_port .filter_type_7 .portfolio_sorts a,#randomtryc0f38th66w6rte2ei_port .filter_type_7 .portfolio_sorts .is-checked{color:#288bd0 !important; }#randomtryc0f38th66w6rte2ei_port .filter_type_7 .portfolio_sorts a,#randomtryc0f38th66w6rte2ei_port .filter_type_7 #sorts{border:1px solid #ecf0f1;}#randomtryc0f38th66w6rte2ei_port .filter_type_7{border-top:1px solid #ecf0f1; border-bottom:double 3px #ecf0f1;}#randomtryc0f38th66w6rte2ei_port .filter_type_7 #options a{background:rgba(255,255,255,0);}#randomtryc0f38th66w6rte2ei_port .filter_type_7 #sorts,#randomtryc0f38th66w6rte2ei_port .filter_type_7 .portfolio_sorts a{background:#ffffff !important;}#randomtryc0f38th66w6rte2ei_port .filter_type_7 #options a,#randomtryc0f38th66w6rte2ei_port .filter_type_7 #sorts{color:#575757}</style><style type="text/css" >#randomtryc0f38th66w6rte2ei_port .portfolio_desc{ position:absolute; bottom:10%; width:100%; height:40px; padding:0; border:none!important; background:none!important; text-align:center; z-index:3; opacity:0;}#randomtryc0f38th66w6rte2ei_port .element:hover .portfolio_desc{opacity:1; bottom:50%;}#randomtryc0f38th66w6rte2ei_port  .element:hover .img_link{left:4px;  opacity:1;}#randomtryc0f38th66w6rte2ei_port  .element:hover .post_link{right:4px; opacity:1;}#randomtryc0f38th66w6rte2ei_port .element:hover .port_overlay{ background:#fff; opacity:1;}#randomtryc0f38th66w6rte2ei_port .portfolio_desc{margin-bottom:-20px;}.img_link,.post_link{display:none;}</style>
				<div id="portfolio-tags" class="filter_type_7">
				<ul class="splitter" id="options"><li><ul class="optionset" data-option-key="filter"><li class="selected"><a href="#filter" data-option-value="*">All</a>
		</li><li ><a href="#filter" data-option-value=".app-idealcity" title="View all post filed under APP Idealcity">APP Idealcity</a>
                </li> <li ><a href="#filter" data-option-value=".automocion" title="View all post filed under Automoción">Automoción</a>
                </li> <li ><a href="#filter" data-option-value=".diseno" title="View all post filed under Diseño">Diseño</a>
                </li> <li ><a href="#filter" data-option-value=".software-de-entretenimiento" title="View all post filed under Software de entretenimiento">Software de entretenimiento</a>
                </li></ul>      </li>        		<li class="portfolio_sorts"><a>Sort by</a><ul id="sorts"  class="button-group"><li data-sort-by="">default</li><li data-sort-by="date">date</li><li data-sort-by="name">name</li></ul></li>
			</ul></div><div class="portfolio_block image-grid columns4 port_type_1 rd_hover_white thumbnail_type_6" id="list"><div data-category="software-de-entretenimiento " class="software-de-entretenimiento  element rd_portfolio_small_squared">
		<div class="filter_img">
		<div class="port_thumb_ctn">
		<div class="port_overlay"></div>
        <a _self href="http://hiades.es/project/extra2/" target="_self" class="ico_link"><img width="960" height="600" src="http://hiades.es/wp-content/uploads/2018/04/museos-de-tenerife-960x600.png" class="attachment-960x600 size-960x600 wp-post-image" alt="" />
		</a><figcaption><div>
		<h2>Extra2</h2>
		<p>software de entretenimiento </p>
		</div>
		<a href="http://hiades.es/project/extra2/" target="_self">View more</a>
		</figcaption><a href="http://hiades.es/wp-content/uploads/2018/04/museos-de-tenerife.png" class="prettyPhoto port_img_link"><span class='img_link'></span></a><a href='http://hiades.es/project/extra2/' target='_self' class='port_post_link'><span class='post_link'><h2 class='fw_port_link'>Extra2</h2><h3 class='fw_port_tag'>software de entretenimiento </h3></span></a><div class="portfolio_desc">
		<h2><a href="http://hiades.es/project/extra2/" target="_self">Extra2</a></h2>
		<h3>software de entretenimiento </h3>
        </div>
		</div><!-- port_thumb_ctn END -->
		</div><!-- Filter img END --><div class="portfolio_sub_info"><div class="isotope_portfolio_name">Extra2</div><div class="isotope_portfolio_date">2018-04-17</div></div></div><!-- element END --><div data-category="app-idealcity " class="app-idealcity  element rd_portfolio_small_squared">
		<div class="filter_img">
		<div class="port_thumb_ctn">
		<div class="port_overlay"></div>
        <a _self href="http://hiades.es/project/extra/" target="_self" class="ico_link"><img width="960" height="600" src="http://hiades.es/wp-content/uploads/2018/04/renovatio-960x600.png" class="attachment-960x600 size-960x600 wp-post-image" alt="" />
		</a><figcaption><div>
		<h2>Extra</h2>
		<p>app idealcity </p>
		</div>
		<a href="http://hiades.es/project/extra/" target="_self">View more</a>
		</figcaption><a href="http://hiades.es/wp-content/uploads/2018/04/renovatio.png" class="prettyPhoto port_img_link"><span class='img_link'></span></a><a href='http://hiades.es/project/extra/' target='_self' class='port_post_link'><span class='post_link'><h2 class='fw_port_link'>Extra</h2><h3 class='fw_port_tag'>app idealcity </h3></span></a><div class="portfolio_desc">
		<h2><a href="http://hiades.es/project/extra/" target="_self">Extra</a></h2>
		<h3>app idealcity </h3>
        </div>
		</div><!-- port_thumb_ctn END -->
		</div><!-- Filter img END --><div class="portfolio_sub_info"><div class="isotope_portfolio_name">Extra</div><div class="isotope_portfolio_date">2018-04-17</div></div></div><!-- element END --><div data-category="automocion " class="automocion  element rd_portfolio_small_squared">
		<div class="filter_img">
		<div class="port_thumb_ctn">
		<div class="port_overlay"></div>
        <a _self href="http://hiades.es/project/automoviles/" target="_self" class="ico_link"><img width="960" height="600" src="http://hiades.es/wp-content/uploads/2018/04/tifon-motor-960x600.png" class="attachment-960x600 size-960x600 wp-post-image" alt="" />
		</a><figcaption><div>
		<h2>Automóviles</h2>
		<p>automoción </p>
		</div>
		<a href="http://hiades.es/project/automoviles/" target="_self">View more</a>
		</figcaption><a href="http://hiades.es/wp-content/uploads/2018/04/tifon-motor.png" class="prettyPhoto port_img_link"><span class='img_link'></span></a><a href='http://hiades.es/project/automoviles/' target='_self' class='port_post_link'><span class='post_link'><h2 class='fw_port_link'>Automóviles</h2><h3 class='fw_port_tag'>automoción </h3></span></a><div class="portfolio_desc">
		<h2><a href="http://hiades.es/project/automoviles/" target="_self">Automóviles</a></h2>
		<h3>automoción </h3>
        </div>
		</div><!-- port_thumb_ctn END -->
		</div><!-- Filter img END --><div class="portfolio_sub_info"><div class="isotope_portfolio_name">Automóviles</div><div class="isotope_portfolio_date">2018-04-16</div></div></div><!-- element END --><div data-category="diseno " class="diseno  element rd_portfolio_small_squared">
		<div class="filter_img">
		<div class="port_thumb_ctn">
		<div class="port_overlay"></div>
        <a _self href="http://hiades.es/project/revista/" target="_self" class="ico_link"><img width="960" height="600" src="http://hiades.es/wp-content/uploads/2018/04/ayto-guimar-960x600.png" class="attachment-960x600 size-960x600 wp-post-image" alt="" />
		</a><figcaption><div>
		<h2>Revista</h2>
		<p>diseño </p>
		</div>
		<a href="http://hiades.es/project/revista/" target="_self">View more</a>
		</figcaption><a href="http://hiades.es/wp-content/uploads/2018/04/ayto-guimar.png" class="prettyPhoto port_img_link"><span class='img_link'></span></a><a href='http://hiades.es/project/revista/' target='_self' class='port_post_link'><span class='post_link'><h2 class='fw_port_link'>Revista</h2><h3 class='fw_port_tag'>diseño </h3></span></a><div class="portfolio_desc">
		<h2><a href="http://hiades.es/project/revista/" target="_self">Revista</a></h2>
		<h3>diseño </h3>
        </div>
		</div><!-- port_thumb_ctn END -->
		</div><!-- Filter img END --><div class="portfolio_sub_info"><div class="isotope_portfolio_name">Revista</div><div class="isotope_portfolio_date">2018-04-16</div></div></div><!-- element END -->

                </div><!-- .portfolio_block -->

                <div class="rd_clear"><!-- ClearFix --></div></div>  <script>
  


jQuery.noConflict();
jQuery(document).ready(function($){
"use strict";
            
 $(window).load(function(){

	$("#randomtryc0f38th66w6rte2ei_port .optionset li a").each(function() {
									
								var filter_class = $(this).attr('data-option-value');
								 if ($('#randomtryc0f38th66w6rte2ei_port').find(filter_class).length){ // implies *not* zero
								$(this).parent('li').show();
								 }else{
								$(this).parent('li').hide();
								 }
								
								
								});
								
                            $('#portfolio-tags').css('opacity','1');
function watchport() {

$("#randomtryc0f38th66w6rte2ei_port .portfolio_block").isotope('layout');
					
					
}

setInterval(watchport, 100);


		   
                });
			
                });	
            </script>
  
		</div> </div>
	</div> 
</div><div  id='HomeClientes'  class="vc_row wpb_row vc_row-fluid vc_custom_1524211555334 full-width-section ">
	<div class="vc_span12 wpb_column vc_column_container "><div class="vc_column-inner ">
		<div class="wpb_wrapper">
			<h2 style="text-align: center;font-family:Lato;font-weight:400;font-style:normal" class="vc_custom_heading Titulo" >NUESTROS CLIENTES</h2>
	<div class="wpb_text_column wpb_content_element  TituloCita " >
		<div class="wpb_wrapper" id="ct_jl7meezv7todym6v0zhb">
			<p style="text-align: center;">"Convierte al cliente en el héroe de tu historia."<br />Ann Handley.</p>

		</div> 
	</div> 
		</div> </div>
	</div> 
</div><div   class="vc_row wpb_row vc_row-fluid  ">
	<div class="vc_span12 wpb_column vc_column_container "><div class="vc_column-inner ">
		<div class="wpb_wrapper">
			<style type="text/css" >#l_sfkt2v74va4jvou9e5p0.sc_line ,#l_sfkt2v74va4jvou9e5p0 .sc_line { height:1px; background:#e8e8e8;}#l_sfkt2v74va4jvou9e5p0 {margin:0px 0 0px 0; padding:0;}</style><div class="clearfix"></div><div id="l_sfkt2v74va4jvou9e5p0"  class="sc_line rd_line_normal" ></div><div class="clearfix" style="padding-top:0px"></div><script type="text/javascript" charset="utf-8">

		jQuery.noConflict();
	//setup up Carousel
		jQuery(document).ready(function($){
			
		"use strict";
		
		$(window).load(function(){
		$("#rd_669inp8w60ol529wd4h2 .partners").carouFredSel({
					responsive: true,
					width: "100%",scroll: 1,
					auto: false,
					prev: "#rd_669inp8w60ol529wd4h2 .partners_left",
					next: "#rd_669inp8w60ol529wd4h2 .partners_right",
					swipe       : {
             		   onTouch     : true,
		               onMouse     : false
        		    },
					items: {
						width: "200",
						height: "variable",
						visible: {
							min: 1,
							max: 5
						}
					}
				});
				});
				});
	</script>
		

	<div class="sponsors" id="rd_669inp8w60ol529wd4h2" >
<div class="partners_nav">
  <p class="partners_left"></p>
  <p class="partners_right"></p>
</div>
<ul class="partners">      
    <li>
    
<img width="360" height="249" src="http://hiades.es/wp-content/uploads/2018/04/rohen-maquinaria.png" class="attachment-sponsor_tn size-sponsor_tn wp-post-image" alt="" title="" srcset="http://hiades.es/wp-content/uploads/2018/04/rohen-maquinaria.png 360w, http://hiades.es/wp-content/uploads/2018/04/rohen-maquinaria-300x208.png 300w" sizes="(max-width: 360px) 100vw, 360px" />      </li>
            
    <li>
    
<img width="360" height="249" src="http://hiades.es/wp-content/uploads/2018/04/grupo-intesa.png" class="attachment-sponsor_tn size-sponsor_tn wp-post-image" alt="" title="" srcset="http://hiades.es/wp-content/uploads/2018/04/grupo-intesa.png 360w, http://hiades.es/wp-content/uploads/2018/04/grupo-intesa-300x208.png 300w" sizes="(max-width: 360px) 100vw, 360px" />      </li>
            
    <li>
    
<img width="360" height="249" src="http://hiades.es/wp-content/uploads/2018/04/spawellplus.png" class="attachment-sponsor_tn size-sponsor_tn wp-post-image" alt="" title="" srcset="http://hiades.es/wp-content/uploads/2018/04/spawellplus.png 360w, http://hiades.es/wp-content/uploads/2018/04/spawellplus-300x208.png 300w" sizes="(max-width: 360px) 100vw, 360px" />      </li>
            
    <li>
    
<img width="360" height="249" src="http://hiades.es/wp-content/uploads/2018/04/ideco.png" class="attachment-sponsor_tn size-sponsor_tn wp-post-image" alt="" title="" srcset="http://hiades.es/wp-content/uploads/2018/04/ideco.png 360w, http://hiades.es/wp-content/uploads/2018/04/ideco-300x208.png 300w" sizes="(max-width: 360px) 100vw, 360px" />      </li>
            
    <li>
    
<img width="360" height="249" src="http://hiades.es/wp-content/uploads/2018/04/el-cardon.png" class="attachment-sponsor_tn size-sponsor_tn wp-post-image" alt="" title="" srcset="http://hiades.es/wp-content/uploads/2018/04/el-cardon.png 360w, http://hiades.es/wp-content/uploads/2018/04/el-cardon-300x208.png 300w" sizes="(max-width: 360px) 100vw, 360px" />      </li>
            
    <li>
    
<img width="360" height="249" src="http://hiades.es/wp-content/uploads/2018/04/factorii.png" class="attachment-sponsor_tn size-sponsor_tn wp-post-image" alt="" title="" srcset="http://hiades.es/wp-content/uploads/2018/04/factorii.png 360w, http://hiades.es/wp-content/uploads/2018/04/factorii-300x208.png 300w" sizes="(max-width: 360px) 100vw, 360px" />      </li>
            </ul>
      </div>
      
      <div class="clearfix" style="padding-top:0px"></div><style type="text/css" >#l_fmnfv97qltedc7atvgp3.sc_line ,#l_fmnfv97qltedc7atvgp3 .sc_line { height:1px; background:#e8e8e8;}#l_fmnfv97qltedc7atvgp3 {margin:0px 0 0px 0; padding:0;}</style><div class="clearfix"></div><div id="l_fmnfv97qltedc7atvgp3"  class="sc_line rd_line_normal" ></div>
		</div> </div>
	</div> 
</div><div  id='HomeProjects'  class="vc_row wpb_row vc_row-fluid vc_custom_1524218106950  ">
	<div class="vc_span12 wpb_column vc_column_container "><div class="vc_column-inner ">
		<div class="wpb_wrapper">
			<h2 style="text-align: center;font-family:Lato;font-weight:400;font-style:normal" class="vc_custom_heading Titulo" >Proyectos</h2>
	<div class="wpb_text_column wpb_content_element  TituloCita " >
		<div class="wpb_wrapper" id="ct_bss8675r2hk6i926hov5">
			<p style="text-align: center;">A lo largo de su trayectoria, Hiades Consulting ha dado cabida a todo tipo de proyectos en distintos países Iberoamericanos y Europa a través de diversas iniciativas empresariales con alto potencial de crecimiento, destacando Digital Dealer Solutions (DDS), Idealcity y Amura, entidad presente ya en 11 puertos nacionales.</p>

		</div> 
	</div> <style type="text/css" >#rp_1d87jma9duzudwzwdird .rd_staff_p03 .member-info{color:#575757;}#rp_1d87jma9duzudwzwdird .rd_staff_p03 .member-info h3 a{color:#333333;}#rp_1d87jma9duzudwzwdird .rd_staff_p03 .member-info h3 a:hover{color:#288bd0;}#rp_1d87jma9duzudwzwdird .rd_staff_p03 .staff_post_ctn:hover .bw-wrapper a:before{background:#288bd0 }#rp_1d87jma9duzudwzwdird .rd_staff_p03 .staff_post_ctn:hover .bw-wrapper{border: 20px solid #333333;}#rp_1d87jma9duzudwzwdird .rd_staff_p03 .member-photo{color:#ecf0f1;}</style><script>



jQuery.noConflict();

jQuery(document).ready(function($){
	
"use strict";

 $(window).load(function(){
							   $(".filter_1d87jma9duzudwzwdird .staffoptionset li a").each(function() {
									
								var filter_class = $(this).attr('data-option-value');
								 if ($('#rp_1d87jma9duzudwzwdird').find(filter_class).length) { // implies *not* zero
								$(this).parent('li').show();
								 }else{
								$(this).parent('li').hide();
								 }
								});	
				
						   
								
								
											
$('.masonry_ctn').isotope({
  // options
  itemSelector : '.staff_post',
  layoutMode : 'masonry'
});


});});


</script>

<div class="rd_staff_posts_ctn masonry_ctn blog_4_col type03" id="rp_1d87jma9duzudwzwdird">

<div data-category="" class="staff_post rd_staff_p03 ajax_post ">

      
      <div class="staff_post_ctn">

  
         <div class="member-photo s_effect">

    <div class="bw-wrapper"> 
			<img width="570" height="570" src="http://hiades.es/wp-content/uploads/2018/04/idealcity-570x570.jpg" class="attachment-staff_tn size-staff_tn wp-post-image" alt="" title="" srcset="http://hiades.es/wp-content/uploads/2018/04/idealcity.jpg 570w, http://hiades.es/wp-content/uploads/2018/04/idealcity-150x150.jpg 150w, http://hiades.es/wp-content/uploads/2018/04/idealcity-300x300.jpg 300w, http://hiades.es/wp-content/uploads/2018/04/idealcity-768x768.jpg 768w, http://hiades.es/wp-content/uploads/2018/04/idealcity-266x266.jpg 266w" sizes="(max-width: 570px) 100vw, 570px" /> 
    </div>

  </div>

  <div class="member-info">

    <h3>
		Idealcity	</h3>

    <span class="position" ></span>
    
  </div>
    


</div>
</div>


<div data-category="" class="staff_post rd_staff_p03 ajax_post ">

      
      <div class="staff_post_ctn">

  
         <div class="member-photo s_effect">

    <div class="bw-wrapper"> 
			<img width="570" height="570" src="http://hiades.es/wp-content/uploads/2018/04/dds-570x570.jpg" class="attachment-staff_tn size-staff_tn wp-post-image" alt="" title="" srcset="http://hiades.es/wp-content/uploads/2018/04/dds.jpg 570w, http://hiades.es/wp-content/uploads/2018/04/dds-150x150.jpg 150w, http://hiades.es/wp-content/uploads/2018/04/dds-300x300.jpg 300w, http://hiades.es/wp-content/uploads/2018/04/dds-768x768.jpg 768w, http://hiades.es/wp-content/uploads/2018/04/dds-266x266.jpg 266w" sizes="(max-width: 570px) 100vw, 570px" /> 
    </div>

  </div>

  <div class="member-info">

    <h3>
		Digital Dealer Solutions	</h3>

    <span class="position" ></span>
    
  </div>
    


</div>
</div>


<div data-category="" class="staff_post rd_staff_p03 ajax_post ">

      
      <div class="staff_post_ctn">

  
         <div class="member-photo s_effect">

    <div class="bw-wrapper"> 
			<img width="570" height="570" src="http://hiades.es/wp-content/uploads/2018/04/amura-570x570.jpg" class="attachment-staff_tn size-staff_tn wp-post-image" alt="" title="" srcset="http://hiades.es/wp-content/uploads/2018/04/amura.jpg 570w, http://hiades.es/wp-content/uploads/2018/04/amura-150x150.jpg 150w, http://hiades.es/wp-content/uploads/2018/04/amura-300x300.jpg 300w, http://hiades.es/wp-content/uploads/2018/04/amura-768x768.jpg 768w, http://hiades.es/wp-content/uploads/2018/04/amura-266x266.jpg 266w" sizes="(max-width: 570px) 100vw, 570px" /> 
    </div>

  </div>

  <div class="member-info">

    <h3>
		Amura	</h3>

    <span class="position" ></span>
    
  </div>
    


</div>
</div>


<div data-category="" class="staff_post rd_staff_p03 ajax_post ">

      
      <div class="staff_post_ctn">

  
         <div class="member-photo s_effect">

    <div class="bw-wrapper"> 
			<img width="570" height="570" src="http://hiades.es/wp-content/uploads/2018/04/dione-570x570.jpg" class="attachment-staff_tn size-staff_tn wp-post-image" alt="" title="" srcset="http://hiades.es/wp-content/uploads/2018/04/dione.jpg 570w, http://hiades.es/wp-content/uploads/2018/04/dione-150x150.jpg 150w, http://hiades.es/wp-content/uploads/2018/04/dione-300x300.jpg 300w, http://hiades.es/wp-content/uploads/2018/04/dione-768x768.jpg 768w, http://hiades.es/wp-content/uploads/2018/04/dione-266x266.jpg 266w" sizes="(max-width: 570px) 100vw, 570px" /> 
    </div>

  </div>

  <div class="member-info">

    <h3>
		Dione	</h3>

    <span class="position" ></span>
    
  </div>
    


</div>
</div>


<div data-category="" class="staff_post rd_staff_p03 ajax_post ">

      
      <div class="staff_post_ctn">

  
         <div class="member-photo s_effect">

    <div class="bw-wrapper"> 
			<img width="570" height="570" src="http://hiades.es/wp-content/uploads/2018/04/tropical-games-570x570.jpg" class="attachment-staff_tn size-staff_tn wp-post-image" alt="" title="" srcset="http://hiades.es/wp-content/uploads/2018/04/tropical-games.jpg 570w, http://hiades.es/wp-content/uploads/2018/04/tropical-games-150x150.jpg 150w, http://hiades.es/wp-content/uploads/2018/04/tropical-games-300x300.jpg 300w, http://hiades.es/wp-content/uploads/2018/04/tropical-games-768x768.jpg 768w, http://hiades.es/wp-content/uploads/2018/04/tropical-games-266x266.jpg 266w" sizes="(max-width: 570px) 100vw, 570px" /> 
    </div>

  </div>

  <div class="member-info">

    <h3>
		Tropical games	</h3>

    <span class="position" ></span>
    
  </div>
    


</div>
</div>


<div data-category="" class="staff_post rd_staff_p03 ajax_post ">

      
      <div class="staff_post_ctn">

  
         <div class="member-photo s_effect">

    <div class="bw-wrapper"> 
			<img width="570" height="570" src="http://hiades.es/wp-content/uploads/2018/04/eheide-570x570.jpg" class="attachment-staff_tn size-staff_tn wp-post-image" alt="" title="" srcset="http://hiades.es/wp-content/uploads/2018/04/eheide.jpg 570w, http://hiades.es/wp-content/uploads/2018/04/eheide-150x150.jpg 150w, http://hiades.es/wp-content/uploads/2018/04/eheide-300x300.jpg 300w, http://hiades.es/wp-content/uploads/2018/04/eheide-768x768.jpg 768w, http://hiades.es/wp-content/uploads/2018/04/eheide-266x266.jpg 266w" sizes="(max-width: 570px) 100vw, 570px" /> 
    </div>

  </div>

  <div class="member-info">

    <h3>
		Eheide	</h3>

    <span class="position" ></span>
    
  </div>
    


</div>
</div>


<div data-category="" class="staff_post rd_staff_p03 ajax_post ">

      
      <div class="staff_post_ctn">

  
         <div class="member-photo s_effect">

    <div class="bw-wrapper"> 
			<img width="570" height="570" src="http://hiades.es/wp-content/uploads/2018/04/pleyone-570x570.jpg" class="attachment-staff_tn size-staff_tn wp-post-image" alt="" title="" srcset="http://hiades.es/wp-content/uploads/2018/04/pleyone.jpg 570w, http://hiades.es/wp-content/uploads/2018/04/pleyone-150x150.jpg 150w, http://hiades.es/wp-content/uploads/2018/04/pleyone-300x300.jpg 300w, http://hiades.es/wp-content/uploads/2018/04/pleyone-768x768.jpg 768w, http://hiades.es/wp-content/uploads/2018/04/pleyone-266x266.jpg 266w" sizes="(max-width: 570px) 100vw, 570px" /> 
    </div>

  </div>

  <div class="member-info">

    <h3>
		Pléyone	</h3>

    <span class="position" ></span>
    
  </div>
    


</div>
</div>


<div data-category="" class="staff_post rd_staff_p03 ajax_post ">

      
      <div class="staff_post_ctn">

  
         <div class="member-photo s_effect">

    <div class="bw-wrapper"> 
			<img width="570" height="570" src="http://hiades.es/wp-content/uploads/2018/04/hiades-570x570.jpg" class="attachment-staff_tn size-staff_tn wp-post-image" alt="" title="" srcset="http://hiades.es/wp-content/uploads/2018/04/hiades.jpg 570w, http://hiades.es/wp-content/uploads/2018/04/hiades-150x150.jpg 150w, http://hiades.es/wp-content/uploads/2018/04/hiades-300x300.jpg 300w, http://hiades.es/wp-content/uploads/2018/04/hiades-768x768.jpg 768w, http://hiades.es/wp-content/uploads/2018/04/hiades-266x266.jpg 266w" sizes="(max-width: 570px) 100vw, 570px" /> 
    </div>

  </div>

  <div class="member-info">

    <h3>
		Hiades	</h3>

    <span class="position" ></span>
    
  </div>
    


</div>
</div>





</div>

		</div> </div>
	</div> 
</div><div  id='HomePressRoom'  class="vc_row wpb_row vc_row-fluid vc_custom_1524218123224  ">
	<div class="vc_span12 wpb_column vc_column_container "><div class="vc_column-inner ">
		<div class="wpb_wrapper">
			<h2 style="text-align: center;font-family:Lato;font-weight:400;font-style:normal" class="vc_custom_heading Titulo" >PRESS ROOM</h2>
	<div class="wpb_text_column wpb_content_element  TituloCita " >
		<div class="wpb_wrapper" id="ct_16c52j11f92ar066c3sh">
			<p style="text-align: center;">"El secreto del éxito desde una perspectiva empresarial es tener una incansable, eterna e<br />inextinguible sed de información y conocimiento." Paul Tudor Jones, empresario.</p>

		</div> 
	</div> <style type="text/css" >#rp_9hsq7ehk641etnybqrrf .post-title h2 a{color:#333333;}#rp_9hsq7ehk641etnybqrrf .rp_post_info,#rp_9hsq7ehk641etnybqrrf .rp_post_info a{color:#575757;}#rp_9hsq7ehk641etnybqrrf .rp_post_time:before,#rp_9hsq7ehk641etnybqrrf .rp_post_comment:before,#rp_9hsq7ehk641etnybqrrf .rp_post_cat:before{color:#288bd0;}#rp_9hsq7ehk641etnybqrrf .post-title h2 a:hover,#rp_9hsq7ehk641etnybqrrf .rp_post_info a:hover{color:#2396e6;}#rp_9hsq7ehk641etnybqrrf .blog_load_more_cont {bottom:-40px;}</style><script>



jQuery.noConflict();
jQuery(document).ready(function($){
"use strict";


 $(window).load(function(){

function watchblog() {

$(".masonry_ctn").isotope({
  // options
  itemSelector : '.ajax_post',
  layoutMode : 'masonry'
});

}

setInterval(watchblog, 100);

});});


</script>



<div class="masonry_ctn blog_3_col" id="rp_9hsq7ehk641etnybqrrf">


<div class=" rp_type01 ajax_post blog_3_col "><a href="http://hiades.es/2018/04/27/por-que-es-importante-el-diseno-grafico-para-el-exito-de-tu-empresa/" title="¿Por qué es importante el Diseño Gráfico para el éxito de tu empresa?">
  <div class='post-attachement'><img width="340" height="400" src="http://hiades.es/wp-content/uploads/2018/04/slider-4-340x400.jpg" class="attachment-340x400 size-340x400 wp-post-image" alt="" /><div class='rp_normal'></div></div>  </a>
  <div class="post_ctn"> 
    <!-- title -->
    <div class="post-title">
      <h2><a href="http://hiades.es/2018/04/27/por-que-es-importante-el-diseno-grafico-para-el-exito-de-tu-empresa/" title="¿Por qué es importante el Diseño Gráfico para el éxito de tu empresa?">
        ¿Por qué es importante el Diseño Gráfico para el éxito de tu empresa?        </a>
      </h2>
    </div>
    <!-- title END--> 
    
    <!-- post-info-top -->
    
    <div class="rp_post_info">
      <div class="rp_post_time">
        27 abril 2018      </div>
      <div class="rp_post_comment">
        <a href="http://hiades.es/2018/04/27/por-que-es-importante-el-diseno-grafico-para-el-exito-de-tu-empresa/#respond" class="comments-link" >0 comment</a>      </div>
      <div class="rp_post_cat">
        <a href="http://hiades.es/category/sin-categoria/" rel="category tag">Sin categoría</a>      </div>
    </div>
    
    <!-- post-info END--> 
    
  </div>
  <!-- post-content END--> 
</div>
<!-- post END -->


<div class=" rp_type01 ajax_post blog_3_col "><a href="http://hiades.es/2018/04/27/la-importacia-del-diseno-responsive/" title="La importacia del diseño responsive">
  <div class='post-attachement'><img width="340" height="400" src="http://hiades.es/wp-content/uploads/2018/04/shutterstock_452239288-340x400.jpg" class="attachment-340x400 size-340x400 wp-post-image" alt="" /><div class='rp_normal'></div></div>  </a>
  <div class="post_ctn"> 
    <!-- title -->
    <div class="post-title">
      <h2><a href="http://hiades.es/2018/04/27/la-importacia-del-diseno-responsive/" title="La importacia del diseño responsive">
        La importacia del diseño responsive        </a>
      </h2>
    </div>
    <!-- title END--> 
    
    <!-- post-info-top -->
    
    <div class="rp_post_info">
      <div class="rp_post_time">
        27 abril 2018      </div>
      <div class="rp_post_comment">
        <a href="http://hiades.es/2018/04/27/la-importacia-del-diseno-responsive/#respond" class="comments-link" >0 comment</a>      </div>
      <div class="rp_post_cat">
        <a href="http://hiades.es/category/sin-categoria/" rel="category tag">Sin categoría</a>      </div>
    </div>
    
    <!-- post-info END--> 
    
  </div>
  <!-- post-content END--> 
</div>
<!-- post END -->

</div>

		</div> </div>
	</div> 
</div><div   class="vc_row wpb_row vc_row-fluid  ">
	<div class="vc_span12 wpb_column vc_column_container "><div class="vc_column-inner ">
		<div class="wpb_wrapper">
			<h2 style="text-align: center;font-family:Lato;font-weight:400;font-style:normal" class="vc_custom_heading Titulo" >ENCUÉNTRANOS EN UN MAPA</h2>
				<div id="map_ol3js_1" class="map undefined" data-map_name="undefined" data-map="map_ol3js_1" style="width:100%; height:450px; overflow:hidden;border:2px solid grey;" >
				  <div id="map_ol3js_1_popup" class="ol-popup" >
					<a href="#" id="map_ol3js_1_popup-closer" class="ol-popup-closer"></a>
					<div id="map_ol3js_1_popup-content" ></div>
				  </div>
				</div>
			
				<link rel="stylesheet" href="http://hiades.es/wp-content/plugins/osm/js/OL/5.3/css/ol.css" type="text/css">
				<link rel="stylesheet" href="http://hiades.es/wp-content/plugins/osm/css/osm_map_v3.css" type="text/css">
				<link rel="stylesheet" href="http://hiades.es/wp-content/plugins/osm/css/osm_map.css" type="text/css">
				<!-- The line below is only needed for old environments like Internet Explorer and Android 4.x -->
				<script src="https://cdn.polyfill.io/v2/polyfill.min.js?features=requestAnimationFrame,Element.prototype.classList,URL"></script>

				<script src="http://hiades.es/wp-content/plugins/osm/js/OL/5.3/ol.js" type="text/javascript"></script>
				<script src="http://hiades.es/wp-content/plugins/osm/js/osm-v3-plugin-lib.js" type="text/javascript"></script>
				<script src="http://hiades.es/wp-content/plugins/osm/js/osm-metabox-events.js" type="text/javascript"></script>
				<script src="http://hiades.es/wp-content/plugins/osm/js/osm-startup-lib.js" type="text/javascript"></script>
				<script type="text/javascript">
					translations['openlayer'] = "open layer";
					translations['openlayerAtStartup'] = "open layer at startup";
					translations['generateLink'] = "link to this map with opened layers";
					translations['shortDescription'] = "short description";
					translations['generatedShortCode'] = "to get a text control link paste this code in your wordpress editor";
					translations['closeLayer'] = "close layer";
					translations['cantGenerateLink'] = "put this string in the existing map short code to control this map";
				</script>

			  <script type="text/javascript">vectorM['map_ol3js_1'] = [];

	var attribution = new ol.control.Attribution({
        collapsible: false
      });
      
      var raster = new ol.layer.Tile({
        source: new ol.source.OSM({ })
      });
        var raster = new ol.layer.Tile({
          source: new ol.source.OSM()
        });
      var Controls = ol.control.defaults({ attribution: false }).extend([
          attribution
      ]); 
			  map_ol3js_1 = new ol.Map({
		controls: Controls,
		
				interactions: ol.interaction.defaults({mouseWheelZoom:false}),
				layers: [raster],
				target: "map_ol3js_1",
				view: new ol.View({
				  center: ol.proj.transform([-16.2714,28.4667], "EPSG:4326", "EPSG:3857"),
				  zoom: 19
				})
			  });
			  
		  var osm_controls = [
			new ol.control.Attribution(),
			new ol.control.MousePosition({
			  undefinedHTML: "outside",
			  projection: "EPSG:4326",
			  coordinateFormat: function(coordinate) {
				 return ol.coordinate.format(coordinate, "{y}, {x}", 5);
			  }
			}),
			new ol.control.OverviewMap({
			  collapsed: false
			}),
			new ol.control.Rotate({
			  autoHide: false
			}),
			new ol.control.ScaleLine(),
			new ol.control.Zoom(),
			new ol.control.ZoomSlider(),
			new ol.control.ZoomToExtent({
      extent: [-11243808.051695308, 1.202710291, 9561377.290892059, 6852382.107835932]
    }),
			new ol.control.FullScreen()
		  ]; 
osm_addPopupClickhandler(map_ol3js_1,  "map_ol3js_1"); 
osm_addMouseHover(map_ol3js_1); </script>
		</div> </div>
	</div> 
</div><div  id='HomeContacto'  class="vc_row wpb_row vc_row-fluid full-width-section ">
	<div class="vc_span6 wpb_column vc_column_container "><div class="vc_column-inner vc_custom_1524820082134">
		<div class="wpb_wrapper">
			
	<div class="wpb_text_column wpb_content_element  " >
		<div class="wpb_wrapper" id="ct_38hke6rvnv3oiyh6z384">
			<h2><span style="color: #ffffff;">Contacta con nosotros</span></h2>
<p><span style="color: #a1b1bc;">Recuerde que puede contactar con nosotros a través de los medios establecidos al efecto, de lunes a viernes, en horario de 8:00 a 16:00 horas.</span></p>
<p><span style="color: #a1b1bc;">Dirección</span><br /><span style="color: #ffffff;">Ramón Trujillo Torres, 6. 2ºB, 38007 Santa Cruz de Tenerife</span></p>
<p><span style="color: #a1b1bc;">Teléfonos</span><br /><span style="color: #ffffff;">+34 922 232 633 - +34 687 594 829</span></p>
<p><span style="color: #a1b1bc;">Email</span><br /><span style="color: #ffffff;">info@hiades.es</span></p>

		</div> 
	</div> 
		</div> </div>
	</div> 

	<div class="vc_span6 wpb_column vc_column_container "><div class="vc_column-inner vc_custom_1524132751546">
		<div class="wpb_wrapper">
			<style type="text/css" >#rd_353dklpzs11v0cqr6eof .wpcf7,#rd_353dklpzs11v0cqr6eof input:not([type=submit]):not([type=checkbox]),#rd_353dklpzs11v0cqr6eof textarea,#rd_353dklpzs11v0cqr6eof .wpcf7 select,#rd_353dklpzs11v0cqr6eof .wpcf7 input[type="checkbox"]:checked{color:#ffffff;}#rd_353dklpzs11v0cqr6eof .wpcf7 input[type="checkbox"]{background:rgba(0,0,0,0); color:rgba(0,0,0,0);}#rd_353dklpzs11v0cqr6eof .wpcf7 input[type=submit]{font-size:15px; font-weight:900; border-radius:2px; padding:11px 15px; letter-spacing: 0.5px; margin-top:3px;}#rd_353dklpzs11v0cqr6eof .wpcf7 input[type=submit]:hover {background:#0033ff; color:#ffffff !important;}#rd_353dklpzs11v0cqr6eof .wpcf7 input:not([type=submit]):not([type=checkbox]),#rd_353dklpzs11v0cqr6eof textarea,#rd_353dklpzs11v0cqr6eof .wpcf7 select{border-radius:0px;}#rd_353dklpzs11v0cqr6eof .wpcf7 input:not([type=submit]),#rd_353dklpzs11v0cqr6eof textarea,#rd_353dklpzs11v0cqr6eof .wpcf7 input[type=submit],#rd_353dklpzs11v0cqr6eof .wpcf7 select{margin-top:3px;}#rd_353dklpzs11v0cqr6eof p{margin-bottom:23px;}#rd_353dklpzs11v0cqr6eof .wpcf7 input:not([type=submit]):not([type=checkbox]),#rd_353dklpzs11v0cqr6eof .wpcf7  textarea,#rd_353dklpzs11v0cqr6eof .wpcf7 select{border:1px solid #282938; background:#282938;}#rd_353dklpzs11v0cqr6eof .wpcf7 input[type=submit]{background:#007ffe; color: !important;}</style><div id="rd_353dklpzs11v0cqr6eof" class=""><div role="form" class="wpcf7" id="wpcf7-f4-o1" lang="es-ES" dir="ltr">
<div class="screen-reader-response"></div>
<form action="/borrador-automatico/#wpcf7-f4-o1" method="post" class="wpcf7-form" novalidate="novalidate">
<div style="display: none;">
<input type="hidden" name="_wpcf7" value="4" />
<input type="hidden" name="_wpcf7_version" value="5.1.4" />
<input type="hidden" name="_wpcf7_locale" value="es_ES" />
<input type="hidden" name="_wpcf7_unit_tag" value="wpcf7-f4-o1" />
<input type="hidden" name="_wpcf7_container_post" value="0" />
<input type="hidden" name="g-recaptcha-response" value="" />
</div>
<p><label> Nombre (requerido)<br />
    <span class="wpcf7-form-control-wrap your-name"><input type="text" name="your-name" value="" size="40" class="wpcf7-form-control wpcf7-text wpcf7-validates-as-required" aria-required="true" aria-invalid="false" /></span> </label></p>
<p><label> Tu correo electrónico (requerido)<br />
    <span class="wpcf7-form-control-wrap your-email"><input type="email" name="your-email" value="" size="40" class="wpcf7-form-control wpcf7-text wpcf7-email wpcf7-validates-as-required wpcf7-validates-as-email" aria-required="true" aria-invalid="false" /></span> </label></p>
<p><label> Asunto (requerido)<br />
    <span class="wpcf7-form-control-wrap your-subject"><input type="text" name="your-subject" value="" size="40" class="wpcf7-form-control wpcf7-text wpcf7-validates-as-required" aria-required="true" aria-invalid="false" /></span> </label></p>
<p><label> Mensaje (requerido)<br />
    <span class="wpcf7-form-control-wrap your-message"><textarea name="your-message" cols="40" rows="10" class="wpcf7-form-control wpcf7-textarea wpcf7-validates-as-required" aria-required="true" aria-invalid="false"></textarea></span> </label></p>
<p><input type="submit" value="Enviar" class="wpcf7-form-control wpcf7-submit" /></p>
<div class="wpcf7-response-output wpcf7-display-none"></div></form></div></div>
		</div> </div>
	</div> 
</div></p></div></div></div></div></div></div></div></div><div class="vce-row-container"><div class="vce-row vce-element--has-background vce-row--col-gap-29 vce-row-columns--top vce-row-content--top" id="el-aef92f6c" data-vce-do-apply="all el-aef92f6c" data-vce-full-width="true"><div class="vce-content-background-container"></div><div class="vce-row-content" data-vce-element-content="true" style="padding-left: 397px; padding-right: 397px;"><div class="vce-col vce-col--md-auto vce-col--xs-1 vce-col--xs-last vce-col--xs-first vce-col--sm-last vce-col--sm-first vce-col--md-last vce-col--lg-last vce-col--xl-last vce-col--md-first vce-col--lg-first vce-col--xl-first" id="el-72b80efc"><div class="vce-col-inner" data-vce-do-apply="border margin background  el-72b80efc"><div class="vce-col-content" data-vce-element-content="true" data-vce-do-apply="padding el-72b80efc"><div class="vce-single-image-container vce-single-image--align-left"><div class="vce vce-single-image-wrapper" id="el-2c54055c" data-vce-do-apply="all el-2c54055c"><figure><div class="vce-single-image-inner"><img class="vce-single-image" data-width="677" data-height="77"src="http://hiades.es/wp-content/uploads/2019/08/logos-negativo-1-677x77.png" data-img-src="http://hiades.es/wp-content/uploads/2019/08/logos-negativo-1.png" alt="" title="logos-negativo"/></div></figure></div></div></div></div></div></div></div></div>
