logo

Author Archives: admin

10 Apr 2020

Viral life


								<li id=\"template-block-1\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\">
				<ul class=\"block-controls\">
					<li class=\"block-control-actions cf\">
						<a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove Column Container\"><i class=\"fa fa-trash\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#my-column-content-1\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit Column Container\"><i class=\"fa fa-pencil\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\" data-toggle=\"modal\"><i class=\"fa fa-upload\"></i></a>
					</li>
				</ul>
				<dt class=\"block-handle ui-sortable-handle\">
	 				<div class=\"block-icon\" style=\"color:none;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span>
					<div class=\"blocknote-self\">About me</div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-1\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-2\" class=\"block block-em_sectionheading span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Display Section Heading\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-2\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"2\" data-mblocktype=\"em_sectionheading\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background-color:#FF6961;\"><i class=\"fa fa-header\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Section Heading</div><div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-2\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Section Heading</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"description_text\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_2][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"description_text\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_2][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-2\">
						<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_2_mtheme_animated\" name=\"aq_blocks[aq_block_2][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\" selected=\"selected\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_title\">Section Heading text</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_2_mtheme_title\" class=\"input-text-full\" value=\"REFUGEES\" name=\"aq_blocks[aq_block_2][mtheme_title]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_subtitle\">Section subtitle (optional)</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_2_mtheme_subtitle\" class=\"input-text-full\" value=\"A VR EXPERIENCE OF THE TRAGEDY OF LESBOS\" name=\"aq_blocks[aq_block_2][mtheme_subtitle]\"></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_align\">Align text</label>
							<span class=\"description_text\">
								Align text
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_2_mtheme_align\" name=\"aq_blocks[aq_block_2][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_size\">Heading size</label>
							<span class=\"description_text\">
								Heading size
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_2_mtheme_size\" name=\"aq_blocks[aq_block_2][mtheme_size]\"><option value=\"1\" selected=\"selected\">h1</option><option value=\"2\">h2</option><option value=\"3\">h3</option><option value=\"4\">h4</option><option value=\"5\">h5</option><option value=\"6\">h6</option></select></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_content_richtext\">Content</label>
							<span class=\"description_text\">
								Add content
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_2_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_2_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_2][mtheme_content_richtext]\" id=\"aq_block_2_mtheme_content_richtext\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_button\">Button Text</label>
							<span class=\"description_text\">
								Button Text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_2_mtheme_button\" class=\"input-text-full\" value=\"WATCH\" name=\"aq_blocks[aq_block_2][mtheme_button]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_button_link\">Button link</label>
							<span class=\"description_text\">
								Button link
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_2_mtheme_button_link\" class=\"input-text-full\" value=\"https://www.eduhernandez.com/fullscreen/refugees/\" name=\"aq_blocks[aq_block_2][mtheme_button_link]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_width\">Width in percent</label>
							<span class=\"description_text\">
								Width in percent
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_2_mtheme_width\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_2][mtheme_width]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_top\">Padding Top in pixels</label>
							<span class=\"description_text\">
								Top Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_2_mtheme_top\" class=\"input-text-full\" value=\"230\" name=\"aq_blocks[aq_block_2][mtheme_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"description_text\">
								Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_2_mtheme_bottom\" class=\"input-text-full\" value=\"150\" name=\"aq_blocks[aq_block_2][mtheme_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"description_text\">
								Margin Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_2_mtheme_marginbottom\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_2][mtheme_marginbottom]\"></span></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_2][id_base]\" value=\"em_sectionheading\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_2][name]\" value=\"Section Heading\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_2][order]\" value=\"1\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_2][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_2][parent]\" value=\"1\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_2][number]\" value=\"2\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li></ul><div id=\"my-column-content-1\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" type=\"text\" name=\"aq_blocks[aq_block_1][blockID]\" value=\"\" id=\"blockID\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" type=\"text\" name=\"aq_blocks[aq_block_1][blockNote]\" value=\"About me\" id=\"blockNote\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_container_type\">Boxed or Fullwidth</label>
							<span class=\"description_text\">
								Boxed or Fullwidth. For full columns
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_1_container_type\" name=\"aq_blocks[aq_block_1][container_type]\"><option value=\"boxed\">Boxed</option><option value=\"fullwidth\" selected=\"selected\">Fullwidth</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_text_intensity\">Text Intensity</label>
							<span class=\"description_text\">
								Text Intensity for headings types
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_1_text_intensity\" name=\"aq_blocks[aq_block_1][text_intensity]\"><option value=\"default\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\" selected=\"selected\">Bright</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_margin_top\">Margin top in pixels</label>
							<span class=\"description_text\">
								Margin top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_1_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][margin_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"description_text\">
								Margin bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_1_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][margin_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_padding_top\">Padding top in pixels</label>
							<span class=\"description_text\">
								Padding top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_1_padding_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][padding_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"description_text\">
								Padding bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_1_padding_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][padding_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_padding_sides\">Padding sides in pixels</label>
							<span class=\"description_text\">
								Padding sides in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_1_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][padding_sides]\"></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_background_color\">Background color</label>
							<span class=\"description_text\">
								Background color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_1_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_1][background_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_gradient_color\">Combine with background color to create Gradients</label>
							<span class=\"description_text\">
								Apply Gradient color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_1_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_1][gradient_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_gradient_angle\">Gradient angle</label>
							<span class=\"description_text\">
								Gradient angle
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_1_gradient_angle\" name=\"aq_blocks[aq_block_1][gradient_angle]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"to_bottom\">to bottom</option><option value=\"to_top\">to top</option><option value=\"to_top_right\">to top right</option><option value=\"to_top_left\">to top left</option><option value=\"to_bottom_right\">to bottom right</option><option value=\"to_bottom_left\">to bottom left</option></select></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_background_image\">Background Image</label>
							<span class=\"description_text\">
								Background Image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"https://www.eduhernandez.com/wp-content/uploads/2017/01/Refugees_thumbnail_template-150x150.jpg\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_1_background_image_imageid\" name=\"aq_blocks[aq_block_1][background_imageid]\" value=\"9772\"><input type=\"text\" readonly=\"\" id=\"aq_block_1_background_image\" class=\"input-full input-upload\" value=\"https://www.eduhernandez.com/wp-content/uploads/2017/01/Refugees_thumbnail_template.jpg\" name=\"aq_blocks[aq_block_1][background_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_background_scroll\">Scroll effect</label>
							<span class=\"description_text\">
								Scroll effect
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_1_background_scroll\" name=\"aq_blocks[aq_block_1][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</option></select></span></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_1][id_base]\" value=\"em_column_block\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_1][name]\" value=\"Column Container\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_1][order]\" value=\"1\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_1][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_1][parent]\" value=\"0\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_1][number]\" value=\"1\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
		<li id=\"template-block-3\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\">
				<ul class=\"block-controls\">
					<li class=\"block-control-actions cf\">
						<a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove Column Container\"><i class=\"fa fa-trash\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#my-column-content-3\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit Column Container\"><i class=\"fa fa-pencil\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\" data-toggle=\"modal\"><i class=\"fa fa-upload\"></i></a>
					</li>
				</ul>
				<dt class=\"block-handle ui-sortable-handle\">
	 				<div class=\"block-icon\" style=\"color:none;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span>
					<div class=\"blocknote-self\"></div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-3\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-4\" class=\"block block-em_sectionheading span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Display Section Heading\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-4\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"4\" data-mblocktype=\"em_sectionheading\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background-color:#FF6961;\"><i class=\"fa fa-header\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Section Heading</div><div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-4\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Section Heading</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"description_text\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_4][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"description_text\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_4][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-4\">
						<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_4_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_4_mtheme_animated\" name=\"aq_blocks[aq_block_4][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\" selected=\"selected\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_4_mtheme_title\">Section Heading text</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_4_mtheme_title\" class=\"input-text-full\" value=\"SOLDADO SANCHEZ\" name=\"aq_blocks[aq_block_4][mtheme_title]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_4_mtheme_subtitle\">Section subtitle (optional)</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_4_mtheme_subtitle\" class=\"input-text-full\" value=\"PILOT OF A WEBSERIE\" name=\"aq_blocks[aq_block_4][mtheme_subtitle]\"></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_4_mtheme_align\">Align text</label>
							<span class=\"description_text\">
								Align text
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_4_mtheme_align\" name=\"aq_blocks[aq_block_4][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_4_mtheme_size\">Heading size</label>
							<span class=\"description_text\">
								Heading size
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_4_mtheme_size\" name=\"aq_blocks[aq_block_4][mtheme_size]\"><option value=\"1\" selected=\"selected\">h1</option><option value=\"2\">h2</option><option value=\"3\">h3</option><option value=\"4\">h4</option><option value=\"5\">h5</option><option value=\"6\">h6</option></select></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_4_mtheme_content_richtext\">Content</label>
							<span class=\"description_text\">
								Add content
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_4_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_4_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_4][mtheme_content_richtext]\" id=\"aq_block_4_mtheme_content_richtext\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_4_mtheme_button\">Button Text</label>
							<span class=\"description_text\">
								Button Text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_4_mtheme_button\" class=\"input-text-full\" value=\"WATCH\" name=\"aq_blocks[aq_block_4][mtheme_button]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_4_mtheme_button_link\">Button link</label>
							<span class=\"description_text\">
								Button link
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_4_mtheme_button_link\" class=\"input-text-full\" value=\"https://www.eduhernandez.com/project/soldado-sanchez/\" name=\"aq_blocks[aq_block_4][mtheme_button_link]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_4_mtheme_width\">Width in percent</label>
							<span class=\"description_text\">
								Width in percent
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_4_mtheme_width\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_4][mtheme_width]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_4_mtheme_top\">Padding Top in pixels</label>
							<span class=\"description_text\">
								Top Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_4_mtheme_top\" class=\"input-text-full\" value=\"230\" name=\"aq_blocks[aq_block_4][mtheme_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_4_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"description_text\">
								Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_4_mtheme_bottom\" class=\"input-text-full\" value=\"150\" name=\"aq_blocks[aq_block_4][mtheme_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_4_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"description_text\">
								Margin Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_4_mtheme_marginbottom\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_4][mtheme_marginbottom]\"></span></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_4][id_base]\" value=\"em_sectionheading\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_4][name]\" value=\"Section Heading\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_4][order]\" value=\"1\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_4][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_4][parent]\" value=\"2\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_4][number]\" value=\"4\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li></ul><div id=\"my-column-content-3\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" type=\"text\" name=\"aq_blocks[aq_block_3][blockID]\" value=\"\" id=\"blockID\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" type=\"text\" name=\"aq_blocks[aq_block_3][blockNote]\" value=\"\" id=\"blockNote\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_3_container_type\">Boxed or Fullwidth</label>
							<span class=\"description_text\">
								Boxed or Fullwidth. For full columns
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_3_container_type\" name=\"aq_blocks[aq_block_3][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_3_text_intensity\">Text Intensity</label>
							<span class=\"description_text\">
								Text Intensity for headings types
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_3_text_intensity\" name=\"aq_blocks[aq_block_3][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_3_margin_top\">Margin top in pixels</label>
							<span class=\"description_text\">
								Margin top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_3_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_3][margin_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_3_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"description_text\">
								Margin bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_3_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_3][margin_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_3_padding_top\">Padding top in pixels</label>
							<span class=\"description_text\">
								Padding top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_3_padding_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_3][padding_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_3_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"description_text\">
								Padding bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_3_padding_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_3][padding_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_3_padding_sides\">Padding sides in pixels</label>
							<span class=\"description_text\">
								Padding sides in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_3_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_3][padding_sides]\"></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_3_background_color\">Background color</label>
							<span class=\"description_text\">
								Background color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_3_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_3][background_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_3_gradient_color\">Combine with background color to create Gradients</label>
							<span class=\"description_text\">
								Apply Gradient color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_3_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_3][gradient_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_3_gradient_angle\">Gradient angle</label>
							<span class=\"description_text\">
								Gradient angle
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_3_gradient_angle\" name=\"aq_blocks[aq_block_3][gradient_angle]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"to_bottom\">to bottom</option><option value=\"to_top\">to top</option><option value=\"to_top_right\">to top right</option><option value=\"to_top_left\">to top left</option><option value=\"to_bottom_right\">to bottom right</option><option value=\"to_bottom_left\">to bottom left</option></select></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_3_background_image\">Background Image</label>
							<span class=\"description_text\">
								Background Image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"https://www.eduhernandez.com/wp-content/uploads/2018/06/Screen-Shot-2018-06-12-at-11.37.16-AM-150x150.png\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_3_background_image_imageid\" name=\"aq_blocks[aq_block_3][background_imageid]\" value=\"10130\"><input type=\"text\" readonly=\"\" id=\"aq_block_3_background_image\" class=\"input-full input-upload\" value=\"https://www.eduhernandez.com/wp-content/uploads/2018/06/Screen-Shot-2018-06-12-at-11.37.16-AM.png\" name=\"aq_blocks[aq_block_3][background_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_3_background_scroll\">Scroll effect</label>
							<span class=\"description_text\">
								Scroll effect
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_3_background_scroll\" name=\"aq_blocks[aq_block_3][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</option></select></span></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_3][id_base]\" value=\"em_column_block\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_3][name]\" value=\"Column Container\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_3][order]\" value=\"2\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_3][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_3][parent]\" value=\"0\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_3][number]\" value=\"3\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
		<li id=\"template-block-5\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\">
				<ul class=\"block-controls\">
					<li class=\"block-control-actions cf\">
						<a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove Column Container\"><i class=\"fa fa-trash\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#my-column-content-5\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit Column Container\"><i class=\"fa fa-pencil\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\" data-toggle=\"modal\"><i class=\"fa fa-upload\"></i></a>
					</li>
				</ul>
				<dt class=\"block-handle ui-sortable-handle\">
	 				<div class=\"block-icon\" style=\"color:none;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span>
					<div class=\"blocknote-self\">Description</div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-5\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-6\" class=\"block block-em_sectionheading span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Display Section Heading\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-6\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"6\" data-mblocktype=\"em_sectionheading\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background-color:#FF6961;\"><i class=\"fa fa-header\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Section Heading</div><div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-6\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Section Heading</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"description_text\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_6][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"description_text\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_6][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-6\">
						<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_6_mtheme_animated\" name=\"aq_blocks[aq_block_6][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\" selected=\"selected\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_title\">Section Heading text</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_6_mtheme_title\" class=\"input-text-full\" value=\"SOUNDS OF A REVOLUTION\" name=\"aq_blocks[aq_block_6][mtheme_title]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_subtitle\">Section subtitle (optional)</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_6_mtheme_subtitle\" class=\"input-text-full\" value=\"October 27th, Catalonia declared independence in the midst of the greatest European political and social conflict after the fall of the Berlin Wall.\" name=\"aq_blocks[aq_block_6][mtheme_subtitle]\"></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_align\">Align text</label>
							<span class=\"description_text\">
								Align text
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_6_mtheme_align\" name=\"aq_blocks[aq_block_6][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_size\">Heading size</label>
							<span class=\"description_text\">
								Heading size
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_6_mtheme_size\" name=\"aq_blocks[aq_block_6][mtheme_size]\"><option value=\"1\" selected=\"selected\">h1</option><option value=\"2\">h2</option><option value=\"3\">h3</option><option value=\"4\">h4</option><option value=\"5\">h5</option><option value=\"6\">h6</option></select></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_content_richtext\">Content</label>
							<span class=\"description_text\">
								Add content
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_6_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_6_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_6][mtheme_content_richtext]\" id=\"aq_block_6_mtheme_content_richtext\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_button\">Button Text</label>
							<span class=\"description_text\">
								Button Text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_6_mtheme_button\" class=\"input-text-full\" value=\"WATCH\" name=\"aq_blocks[aq_block_6][mtheme_button]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_button_link\">Button link</label>
							<span class=\"description_text\">
								Button link
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_6_mtheme_button_link\" class=\"input-text-full\" value=\"https://www.eduhernandez.com/fullscreen/sounds-of-a-revolution/\" name=\"aq_blocks[aq_block_6][mtheme_button_link]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_width\">Width in percent</label>
							<span class=\"description_text\">
								Width in percent
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_6_mtheme_width\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_6][mtheme_width]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_top\">Padding Top in pixels</label>
							<span class=\"description_text\">
								Top Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_6_mtheme_top\" class=\"input-text-full\" value=\"230\" name=\"aq_blocks[aq_block_6][mtheme_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"description_text\">
								Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_6_mtheme_bottom\" class=\"input-text-full\" value=\"150\" name=\"aq_blocks[aq_block_6][mtheme_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"description_text\">
								Margin Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_6_mtheme_marginbottom\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_6][mtheme_marginbottom]\"></span></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_6][id_base]\" value=\"em_sectionheading\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_6][name]\" value=\"Section Heading\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_6][order]\" value=\"1\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_6][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_6][parent]\" value=\"3\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_6][number]\" value=\"6\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li></ul><div id=\"my-column-content-5\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" type=\"text\" name=\"aq_blocks[aq_block_5][blockID]\" value=\"\" id=\"blockID\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" type=\"text\" name=\"aq_blocks[aq_block_5][blockNote]\" value=\"Description\" id=\"blockNote\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_container_type\">Boxed or Fullwidth</label>
							<span class=\"description_text\">
								Boxed or Fullwidth. For full columns
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_5_container_type\" name=\"aq_blocks[aq_block_5][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_text_intensity\">Text Intensity</label>
							<span class=\"description_text\">
								Text Intensity for headings types
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_5_text_intensity\" name=\"aq_blocks[aq_block_5][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_margin_top\">Margin top in pixels</label>
							<span class=\"description_text\">
								Margin top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_5_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_5][margin_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"description_text\">
								Margin bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_5_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_5][margin_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_padding_top\">Padding top in pixels</label>
							<span class=\"description_text\">
								Padding top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_5_padding_top\" class=\"input-text-full\" value=\"80\" name=\"aq_blocks[aq_block_5][padding_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"description_text\">
								Padding bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_5_padding_bottom\" class=\"input-text-full\" value=\"50\" name=\"aq_blocks[aq_block_5][padding_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_padding_sides\">Padding sides in pixels</label>
							<span class=\"description_text\">
								Padding sides in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_5_padding_sides\" class=\"input-text-full\" value=\"50\" name=\"aq_blocks[aq_block_5][padding_sides]\"></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_background_color\">Background color</label>
							<span class=\"description_text\">
								Background color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_5_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_5][background_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_gradient_color\">Combine with background color to create Gradients</label>
							<span class=\"description_text\">
								Apply Gradient color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_5_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_5][gradient_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_gradient_angle\">Gradient angle</label>
							<span class=\"description_text\">
								Gradient angle
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_5_gradient_angle\" name=\"aq_blocks[aq_block_5][gradient_angle]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"to_bottom\">to bottom</option><option value=\"to_top\">to top</option><option value=\"to_top_right\">to top right</option><option value=\"to_top_left\">to top left</option><option value=\"to_bottom_right\">to bottom right</option><option value=\"to_bottom_left\">to bottom left</option></select></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_background_image\">Background Image</label>
							<span class=\"description_text\">
								Background Image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/intro-titles-barcelona_web-2-150x150.jpg\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_5_background_image_imageid\" name=\"aq_blocks[aq_block_5][background_imageid]\" value=\"9979\"><input type=\"text\" readonly=\"\" id=\"aq_block_5_background_image\" class=\"input-full input-upload\" value=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/intro-titles-barcelona_web-2.jpg\" name=\"aq_blocks[aq_block_5][background_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_background_scroll\">Scroll effect</label>
							<span class=\"description_text\">
								Scroll effect
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_5_background_scroll\" name=\"aq_blocks[aq_block_5][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</option></select></span></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_5][id_base]\" value=\"em_column_block\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_5][name]\" value=\"Fullwidth Container\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_5][order]\" value=\"3\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_5][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_5][parent]\" value=\"0\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_5][number]\" value=\"5\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
		<li id=\"template-block-7\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\">
				<ul class=\"block-controls\">
					<li class=\"block-control-actions cf\">
						<a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove Column Container\"><i class=\"fa fa-trash\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#my-column-content-7\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit Column Container\"><i class=\"fa fa-pencil\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\" data-toggle=\"modal\"><i class=\"fa fa-upload\"></i></a>
					</li>
				</ul>
				<dt class=\"block-handle ui-sortable-handle\">
	 				<div class=\"block-icon\" style=\"color:none;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span>
					<div class=\"blocknote-self\"></div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-7\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-8\" class=\"block block-em_sectionheading span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Display Section Heading\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-8\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"8\" data-mblocktype=\"em_sectionheading\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background-color:#FF6961;\"><i class=\"fa fa-header\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Section Heading</div><div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-8\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Section Heading</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"description_text\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_8][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"description_text\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_8][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-8\">
						<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_8_mtheme_animated\" name=\"aq_blocks[aq_block_8][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\" selected=\"selected\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_title\">Section Heading text</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_8_mtheme_title\" class=\"input-text-full\" value=\"VRRIOT\" name=\"aq_blocks[aq_block_8][mtheme_title]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_subtitle\">Section subtitle (optional)</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_8_mtheme_subtitle\" class=\"input-text-full\" value=\"VR EXPERIENCE OF A RIOT IN FRANCE.\" name=\"aq_blocks[aq_block_8][mtheme_subtitle]\"></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_align\">Align text</label>
							<span class=\"description_text\">
								Align text
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_8_mtheme_align\" name=\"aq_blocks[aq_block_8][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_size\">Heading size</label>
							<span class=\"description_text\">
								Heading size
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_8_mtheme_size\" name=\"aq_blocks[aq_block_8][mtheme_size]\"><option value=\"1\" selected=\"selected\">h1</option><option value=\"2\">h2</option><option value=\"3\">h3</option><option value=\"4\">h4</option><option value=\"5\">h5</option><option value=\"6\">h6</option></select></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_content_richtext\">Content</label>
							<span class=\"description_text\">
								Add content
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_8_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_8_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_8][mtheme_content_richtext]\" id=\"aq_block_8_mtheme_content_richtext\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_button\">Button Text</label>
							<span class=\"description_text\">
								Button Text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_8_mtheme_button\" class=\"input-text-full\" value=\"WATCH\" name=\"aq_blocks[aq_block_8][mtheme_button]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_button_link\">Button link</label>
							<span class=\"description_text\">
								Button link
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_8_mtheme_button_link\" class=\"input-text-full\" value=\"https://www.eduhernandez.com/fullscreen/vriot/\" name=\"aq_blocks[aq_block_8][mtheme_button_link]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_width\">Width in percent</label>
							<span class=\"description_text\">
								Width in percent
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_8_mtheme_width\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_8][mtheme_width]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_top\">Padding Top in pixels</label>
							<span class=\"description_text\">
								Top Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_8_mtheme_top\" class=\"input-text-full\" value=\"230\" name=\"aq_blocks[aq_block_8][mtheme_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"description_text\">
								Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_8_mtheme_bottom\" class=\"input-text-full\" value=\"150\" name=\"aq_blocks[aq_block_8][mtheme_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"description_text\">
								Margin Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_8_mtheme_marginbottom\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_8][mtheme_marginbottom]\"></span></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_8][id_base]\" value=\"em_sectionheading\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_8][name]\" value=\"Section Heading\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_8][order]\" value=\"1\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_8][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_8][parent]\" value=\"4\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_8][number]\" value=\"8\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li></ul><div id=\"my-column-content-7\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" type=\"text\" name=\"aq_blocks[aq_block_7][blockID]\" value=\"\" id=\"blockID\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" type=\"text\" name=\"aq_blocks[aq_block_7][blockNote]\" value=\"\" id=\"blockNote\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_container_type\">Boxed or Fullwidth</label>
							<span class=\"description_text\">
								Boxed or Fullwidth. For full columns
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_7_container_type\" name=\"aq_blocks[aq_block_7][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_text_intensity\">Text Intensity</label>
							<span class=\"description_text\">
								Text Intensity for headings types
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_7_text_intensity\" name=\"aq_blocks[aq_block_7][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_margin_top\">Margin top in pixels</label>
							<span class=\"description_text\">
								Margin top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_7_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_7][margin_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"description_text\">
								Margin bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_7_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_7][margin_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_padding_top\">Padding top in pixels</label>
							<span class=\"description_text\">
								Padding top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_7_padding_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_7][padding_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"description_text\">
								Padding bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_7_padding_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_7][padding_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_padding_sides\">Padding sides in pixels</label>
							<span class=\"description_text\">
								Padding sides in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_7_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_7][padding_sides]\"></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_background_color\">Background color</label>
							<span class=\"description_text\">
								Background color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_7_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_7][background_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_gradient_color\">Combine with background color to create Gradients</label>
							<span class=\"description_text\">
								Apply Gradient color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_7_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_7][gradient_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_gradient_angle\">Gradient angle</label>
							<span class=\"description_text\">
								Gradient angle
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_7_gradient_angle\" name=\"aq_blocks[aq_block_7][gradient_angle]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"to_bottom\">to bottom</option><option value=\"to_top\">to top</option><option value=\"to_top_right\">to top right</option><option value=\"to_top_left\">to top left</option><option value=\"to_bottom_right\">to bottom right</option><option value=\"to_bottom_left\">to bottom left</option></select></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_background_image\">Background Image</label>
							<span class=\"description_text\">
								Background Image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"https://www.eduhernandez.com/wp-content/uploads/2020/01/VR-RIOT-150x150.jpg\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_7_background_image_imageid\" name=\"aq_blocks[aq_block_7][background_imageid]\" value=\"10382\"><input type=\"text\" readonly=\"\" id=\"aq_block_7_background_image\" class=\"input-full input-upload\" value=\"https://www.eduhernandez.com/wp-content/uploads/2020/01/VR-RIOT.jpg\" name=\"aq_blocks[aq_block_7][background_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_background_scroll\">Scroll effect</label>
							<span class=\"description_text\">
								Scroll effect
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_7_background_scroll\" name=\"aq_blocks[aq_block_7][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</option></select></span></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_7][id_base]\" value=\"em_column_block\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_7][name]\" value=\"Column Container\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_7][order]\" value=\"4\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_7][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_7][parent]\" value=\"0\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_7][number]\" value=\"7\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
		<li id=\"template-block-9\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\">
				<ul class=\"block-controls\">
					<li class=\"block-control-actions cf\">
						<a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove Column Container\"><i class=\"fa fa-trash\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#my-column-content-9\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit Column Container\"><i class=\"fa fa-pencil\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\" data-toggle=\"modal\"><i class=\"fa fa-upload\"></i></a>
					</li>
				</ul>
				<dt class=\"block-handle ui-sortable-handle\">
	 				<div class=\"block-icon\" style=\"color:none;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span>
					<div class=\"blocknote-self\"></div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-9\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-10\" class=\"block block-em_sectionheading span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Display Section Heading\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-10\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"10\" data-mblocktype=\"em_sectionheading\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background-color:#FF6961;\"><i class=\"fa fa-header\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Section Heading</div><div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-10\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Section Heading</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"description_text\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_10][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"description_text\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_10][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-10\">
						<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_10_mtheme_animated\" name=\"aq_blocks[aq_block_10][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\" selected=\"selected\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_title\">Section Heading text</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_10_mtheme_title\" class=\"input-text-full\" value=\"A LIFE STORY\" name=\"aq_blocks[aq_block_10][mtheme_title]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_subtitle\">Section subtitle (optional)</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_10_mtheme_subtitle\" class=\"input-text-full\" value=\"ONE OF THE PIONEER OF MEDICAL CANNABIS IN GERMANY\" name=\"aq_blocks[aq_block_10][mtheme_subtitle]\"></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_align\">Align text</label>
							<span class=\"description_text\">
								Align text
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_10_mtheme_align\" name=\"aq_blocks[aq_block_10][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_size\">Heading size</label>
							<span class=\"description_text\">
								Heading size
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_10_mtheme_size\" name=\"aq_blocks[aq_block_10][mtheme_size]\"><option value=\"1\" selected=\"selected\">h1</option><option value=\"2\">h2</option><option value=\"3\">h3</option><option value=\"4\">h4</option><option value=\"5\">h5</option><option value=\"6\">h6</option></select></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_content_richtext\">Content</label>
							<span class=\"description_text\">
								Add content
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_10_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_10_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_10][mtheme_content_richtext]\" id=\"aq_block_10_mtheme_content_richtext\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_button\">Button Text</label>
							<span class=\"description_text\">
								Button Text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_10_mtheme_button\" class=\"input-text-full\" value=\"WATCH trailer\" name=\"aq_blocks[aq_block_10][mtheme_button]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_button_link\">Button link</label>
							<span class=\"description_text\">
								Button link
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_10_mtheme_button_link\" class=\"input-text-full\" value=\"https://www.eduhernandez.com/project/the-doctor-franjo-grotenhermen/\" name=\"aq_blocks[aq_block_10][mtheme_button_link]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_width\">Width in percent</label>
							<span class=\"description_text\">
								Width in percent
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_10_mtheme_width\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_10][mtheme_width]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_top\">Padding Top in pixels</label>
							<span class=\"description_text\">
								Top Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_10_mtheme_top\" class=\"input-text-full\" value=\"230\" name=\"aq_blocks[aq_block_10][mtheme_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"description_text\">
								Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_10_mtheme_bottom\" class=\"input-text-full\" value=\"150\" name=\"aq_blocks[aq_block_10][mtheme_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"description_text\">
								Margin Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_10_mtheme_marginbottom\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_10][mtheme_marginbottom]\"></span></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_10][id_base]\" value=\"em_sectionheading\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_10][name]\" value=\"Section Heading\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_10][order]\" value=\"1\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_10][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_10][parent]\" value=\"5\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_10][number]\" value=\"10\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li></ul><div id=\"my-column-content-9\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" type=\"text\" name=\"aq_blocks[aq_block_9][blockID]\" value=\"\" id=\"blockID\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" type=\"text\" name=\"aq_blocks[aq_block_9][blockNote]\" value=\"\" id=\"blockNote\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_container_type\">Boxed or Fullwidth</label>
							<span class=\"description_text\">
								Boxed or Fullwidth. For full columns
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_9_container_type\" name=\"aq_blocks[aq_block_9][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_text_intensity\">Text Intensity</label>
							<span class=\"description_text\">
								Text Intensity for headings types
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_9_text_intensity\" name=\"aq_blocks[aq_block_9][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_margin_top\">Margin top in pixels</label>
							<span class=\"description_text\">
								Margin top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_9_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_9][margin_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"description_text\">
								Margin bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_9_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_9][margin_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_padding_top\">Padding top in pixels</label>
							<span class=\"description_text\">
								Padding top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_9_padding_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_9][padding_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"description_text\">
								Padding bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_9_padding_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_9][padding_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_padding_sides\">Padding sides in pixels</label>
							<span class=\"description_text\">
								Padding sides in pixels
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_9_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_9][padding_sides]\"></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_background_color\">Background color</label>
							<span class=\"description_text\">
								Background color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_9_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_9][background_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_gradient_color\">Combine with background color to create Gradients</label>
							<span class=\"description_text\">
								Apply Gradient color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_9_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_9][gradient_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_gradient_angle\">Gradient angle</label>
							<span class=\"description_text\">
								Gradient angle
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_9_gradient_angle\" name=\"aq_blocks[aq_block_9][gradient_angle]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"to_bottom\">to bottom</option><option value=\"to_top\">to top</option><option value=\"to_top_right\">to top right</option><option value=\"to_top_left\">to top left</option><option value=\"to_bottom_right\">to bottom right</option><option value=\"to_bottom_left\">to bottom left</option></select></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_background_image\">Background Image</label>
							<span class=\"description_text\">
								Background Image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"https://www.eduhernandez.com/wp-content/uploads/2020/01/WIP.mov-VLC-media-player-15_12_2019-18_10_39-2-150x150.png\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_9_background_image_imageid\" name=\"aq_blocks[aq_block_9][background_imageid]\" value=\"10350\"><input type=\"text\" readonly=\"\" id=\"aq_block_9_background_image\" class=\"input-full input-upload\" value=\"https://www.eduhernandez.com/wp-content/uploads/2020/01/WIP.mov-VLC-media-player-15_12_2019-18_10_39-2.png\" name=\"aq_blocks[aq_block_9][background_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_background_scroll\">Scroll effect</label>
							<span class=\"description_text\">
								Scroll effect
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_9_background_scroll\" name=\"aq_blocks[aq_block_9][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</option></select></span></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_9][id_base]\" value=\"em_column_block\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_9][name]\" value=\"Column Container\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_9][order]\" value=\"5\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_9][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_9][parent]\" value=\"0\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_9][number]\" value=\"9\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
		<li id=\"template-block-11\" class=\"block block-em_sectionheading span12   ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Display Section Heading\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-11\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"11\" data-mblocktype=\"em_sectionheading\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle ui-sortable-handle\"><div class=\"block-icon\" style=\"background-color:#FF6961;\"><i class=\"fa fa-header\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Section Heading</div><div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-11\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Section Heading</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"description_text\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_11][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"description_text\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_11][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-11\">
						<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_11_mtheme_animated\" name=\"aq_blocks[aq_block_11][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_title\">Section Heading text</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_11_mtheme_title\" class=\"input-text-full\" value=\"Pictures \" name=\"aq_blocks[aq_block_11][mtheme_title]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_subtitle\">Section subtitle (optional)</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_11_mtheme_subtitle\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_11][mtheme_subtitle]\"></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_align\">Align text</label>
							<span class=\"description_text\">
								Align text
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_11_mtheme_align\" name=\"aq_blocks[aq_block_11][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_size\">Heading size</label>
							<span class=\"description_text\">
								Heading size
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_11_mtheme_size\" name=\"aq_blocks[aq_block_11][mtheme_size]\"><option value=\"1\">h1</option><option value=\"2\" selected=\"selected\">h2</option><option value=\"3\">h3</option><option value=\"4\">h4</option><option value=\"5\">h5</option><option value=\"6\">h6</option></select></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_content_richtext\">Content</label>
							<span class=\"description_text\">
								Add content
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_11_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_11_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_11][mtheme_content_richtext]\" id=\"aq_block_11_mtheme_content_richtext\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_button\">Button Text</label>
							<span class=\"description_text\">
								Button Text
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_11_mtheme_button\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_11][mtheme_button]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_button_link\">Button link</label>
							<span class=\"description_text\">
								Button link
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_11_mtheme_button_link\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_11][mtheme_button_link]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_width\">Width in percent</label>
							<span class=\"description_text\">
								Width in percent
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_11_mtheme_width\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_11][mtheme_width]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_top\">Padding Top in pixels</label>
							<span class=\"description_text\">
								Top Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_11_mtheme_top\" class=\"input-text-full\" value=\"50\" name=\"aq_blocks[aq_block_11][mtheme_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"description_text\">
								Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_11_mtheme_bottom\" class=\"input-text-full\" value=\"10\" name=\"aq_blocks[aq_block_11][mtheme_bottom]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"description_text\">
								Margin Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_11_mtheme_marginbottom\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_11][mtheme_marginbottom]\"></span></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_11][id_base]\" value=\"em_sectionheading\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_11][name]\" value=\"Section Heading\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_11][order]\" value=\"6\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_11][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_11][parent]\" value=\"0\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_11][number]\" value=\"11\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-12\" class=\"block block-em_dividers span12   ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add a divider\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-12\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"12\" data-mblocktype=\"em_dividers\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle ui-sortable-handle\"><div class=\"block-icon\" style=\"background-color:#9c9c9c;\"><i class=\"fa fa-arrows-v\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Dividers</div><div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-12\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Dividers</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"description_text\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_12][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"description_text\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_12][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-12\">
						<div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_12_mtheme_style\">Choose Divider</label>
							<span class=\"description_text\">
								Choose Divider
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_12_mtheme_style\" name=\"aq_blocks[aq_block_12][mtheme_style]\"><option value=\"blank\" selected=\"selected\">blank</option><option value=\"line\">line</option><option value=\"double\">double</option><option value=\"stripes\">stripes</option><option value=\"thinfade\">thinfade</option><option value=\"threelines\">threelines</option><option value=\"circleline\">circleline</option><option value=\"stripedcenter\">stripedcenter</option><option value=\"linedcenter\">linedcenter</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_12_mtheme_type\">Divider Type</label>
							<span class=\"description_text\">
								Divider Type
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_12_mtheme_type\" name=\"aq_blocks[aq_block_12][mtheme_type]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"bright\">Bright</option><option value=\"dark\">Dark</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_12_mtheme_top\">Top Space in pixels</label>
							<span class=\"description_text\">
								Top Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_12_mtheme_top\" class=\"input-text-full\" value=\"0\" name=\"aq_blocks[aq_block_12][mtheme_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_12_mtheme_bottom\">Bottom Space pixels</label>
							<span class=\"description_text\">
								Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_12_mtheme_bottom\" class=\"input-text-full\" value=\"50\" name=\"aq_blocks[aq_block_12][mtheme_bottom]\"></span></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_12][id_base]\" value=\"em_dividers\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_12][name]\" value=\"Dividers\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_12][order]\" value=\"7\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_12][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_12][parent]\" value=\"0\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_12][number]\" value=\"12\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-13\" class=\"block block-em_metro span12   ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Display Metro Grid\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-13\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"13\" data-mblocktype=\"em_metro\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle ui-sortable-handle\"><div class=\"block-icon\" style=\"background-color:#E1A43C;\"><i class=\"simpleicon-grid\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Metro Grid</div><div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-13\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Metro Grid</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"description_text\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_13][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"description_text\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_13][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-13\">
						<div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_13_mtheme_animated\">On scroll animated</label>
							<span class=\"description_text\">
								Display animated images while scrolling
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_13_mtheme_animated\" name=\"aq_blocks[aq_block_13][mtheme_animated]\"><option value=\"false\">No</option><option value=\"true\" selected=\"selected\">Yes</option></select></span></div><div class=\"description mtheme-input-type-is-images\"><span class=\"leftHalf\">
							<label for=\"aq_block_13_mtheme_pb_image_ids\">Add images</label>
							<span class=\"description_text\">
								Add images
							</span>
						</span><span class=\"rightHalf images\"><input type=\"hidden\" class=\"mtheme-gallery-selector-ids\" value=\"9312,9307,9306,9308,9313,9304,9311,10142,10143,10144,10145,10146,10147,9981,9989,9990,9991,9992,9959,9958,9957,9955,9954,9953,9951,9950,9956\" name=\"aq_blocks[aq_block_13][mtheme_pb_image_ids]\"><button type=\"button\" class=\"mtheme-gallery-selector\">select</button><div class=\"description\"><ul class=\"mtheme-gallery-selector-list\"><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2017/01/12308131_10153580303808891_1805547499018180771_o-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2017/01/12366150_10153783949228891_941434802489231360_o-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2017/01/12829391_10153783948743891_1539391775885234391_o-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2017/01/1421091_10153783949388891_4686071517387133745_o-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2017/01/12314210_10153580303603891_6747776202430305226_o-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2017/01/10623935_10153783948193891_4554080538482249206_o-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2017/01/12339436_10153580303803891_1427523427031684880_o-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/09/Screen-Shot-2016-08-07-at-1.49.45-PM-150x150.png\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/09/Screen-Shot-2016-08-07-at-1.50.15-PM-150x150.png\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/09/Screen-Shot-2016-08-07-at-1.50.29-PM-150x150.png\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/09/Screen-Shot-2016-08-07-at-1.48.19-PM-150x150.png\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/09/Screen-Shot-2016-08-07-at-1.48.34-PM-150x150.png\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/09/Screen-Shot-2016-08-07-at-1.49.13-PM-150x150.png\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/barcelona_web2-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/IMG_6771_low-2-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/IMG_6595-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/IMG_6586-1-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/IMG_6600_1-2-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/27355656_10155651890958891_8405037119188272895_o-1-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/27173157_10155651891093891_7791163251757185565_o-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/26951942_10155651891063891_7026108494295987045_o-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/26962286_10155651891233891_7135355408981313173_o-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/26961927_10155651891243891_7465904393195691145_o-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/26952235_10155651891088891_4624681026676153752_o-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/26910620_10155651891218891_7115979876882632873_o-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/27023378_10155651890953891_7344572710216409122_o-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://www.eduhernandez.com/wp-content/uploads/2018/01/26910275_10155651890963891_1769955875973103915_o-150x150.jpg\" width=\"150\" height=\"150\" alt=\"\"></li></ul></div></span></div>		
		<input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_13][id_base]\" value=\"em_metro\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_13][name]\" value=\"Metro Grid\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_13][order]\" value=\"8\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_13][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_13][parent]\" value=\"0\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_13][number]\" value=\"13\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-14\" class=\"block block-em_dividers span12   ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add a divider\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-14\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"14\" data-mblocktype=\"em_dividers\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle ui-sortable-handle\"><div class=\"block-icon\" style=\"background-color:#9c9c9c;\"><i class=\"fa fa-arrows-v\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Dividers</div><div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-14\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Dividers</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"description_text\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_14][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"description_text\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_14][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-14\">
						<div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_14_mtheme_style\">Choose Divider</label>
							<span class=\"description_text\">
								Choose Divider
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_14_mtheme_style\" name=\"aq_blocks[aq_block_14][mtheme_style]\"><option value=\"blank\" selected=\"selected\">blank</option><option value=\"line\">line</option><option value=\"double\">double</option><option value=\"stripes\">stripes</option><option value=\"thinfade\">thinfade</option><option value=\"threelines\">threelines</option><option value=\"circleline\">circleline</option><option value=\"stripedcenter\">stripedcenter</option><option value=\"linedcenter\">linedcenter</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_14_mtheme_type\">Divider Type</label>
							<span class=\"description_text\">
								Divider Type
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_14_mtheme_type\" name=\"aq_blocks[aq_block_14][mtheme_type]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"bright\">Bright</option><option value=\"dark\">Dark</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_14_mtheme_top\">Top Space in pixels</label>
							<span class=\"description_text\">
								Top Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_14_mtheme_top\" class=\"input-text-full\" value=\"0\" name=\"aq_blocks[aq_block_14][mtheme_top]\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_14_mtheme_bottom\">Bottom Space pixels</label>
							<span class=\"description_text\">
								Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input type=\"text\" id=\"aq_block_14_mtheme_bottom\" class=\"input-text-full\" value=\"80\" name=\"aq_blocks[aq_block_14][mtheme_bottom]\"></span></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_14][id_base]\" value=\"em_dividers\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_14][name]\" value=\"Dividers\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_14][order]\" value=\"9\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_14][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_14][parent]\" value=\"0\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_14][number]\" value=\"14\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-15\" class=\"block block-em_displayrichtext span12   ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Richtext\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-15\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"15\" data-mblocktype=\"em_displayrichtext\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle ui-sortable-handle\"><div class=\"block-icon\" style=\"background-color:#E1A43C;\"><i class=\"simpleicon-pencil\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Richtext Box</div><div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-15\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Richtext Box</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"description_text\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_15][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"description_text\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_15][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-15\">
						<div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_15_mtheme_content_richtext\">Rich Text</label>
							<span class=\"description_text\">
								Add the content
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_15_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_15_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_15][mtheme_content_richtext]\" id=\"aq_block_15_mtheme_content_richtext\">&lt;div dir=\"ltr\"&gt;
&lt;blockquote class=\"m_-8960186946456235434clean_bq\"&gt;&lt;strong&gt;Official selection at VREFEST, Italy, 2019&lt;/strong&gt;

&lt;strong&gt;Showcase at Busan International Film Festival &nbsp;(BIFF) Korea. 2019&lt;/strong&gt;
Busan International Film Festival, the most dynamic film event in Asia as well as the largest Asian film celebration.
&lt;h4 class=\"pv-accomplishment-entity__title\"&gt;Showcase at Seoul International NewMedia Festival (NeMaf) Korea 2018&lt;/h4&gt;
NeMaf has since been destorying the boundaries between video and art with creative energy and passion. It is dedicated to introducing new media art works that offer new imaginations and new uses for art and media.

The festival is highly interactive, encouraging communication between artists and audiences.
&lt;h4 class=\"pv-accomplishment-entity__title\"&gt;Showcase at the Nouveaux Cinema Festival, France&lt;/h4&gt;
&lt;h4 class=\"pv-accomplishment-entity__title\"&gt;Showcase at the&nbsp;&lt;strong&gt;Rochester Institute of Technology in New York&lt;/strong&gt;&lt;/h4&gt;
Frameless Labs and the MAGIC Center at Rochester Institute of Technology are a collaborative community that serves to foster efforts in emerging media, content, and technology throughout the Rochester region.
&lt;h4 class=\"pv-accomplishment-entity__title\"&gt;&nbsp;Official Selection &nbsp;at Movies that matter, The Netherland&lt;/h4&gt;
Founded in March 2006, Movies that Matter followed in the footsteps of the Amnesty International Film Festival.

It continued and enhanced the festival’s activities, both in the Netherlands and abroad.
&lt;h4 class=\"pv-accomplishment-entity__title\"&gt;Official Finalist at SIMA (Social Impact Media Awards), U.S.A&lt;/h4&gt;
&lt;p class=\"pv-accomplishment-entity__description Sans-15px-black-70%\"&gt;SIMA (Social Impact Media Awards) is an annual global film competition and traveling series celebrating eye-opening impact cinema from around the world that inspires activism, compassion, and social transformation.&lt;/p&gt;

&lt;h4 class=\"pv-accomplishment-entity__title\"&gt;Showcase at the World Government Summit 2017, Dubai&lt;/h4&gt;
&lt;p class=\"pv-accomplishment-entity__subtitle\"&gt;&lt;span class=\"pv-accomplishment-entity__issuer\"&gt;World Government Summit, Dubai 2017&lt;/span&gt;&lt;/p&gt;
&lt;p class=\"pv-accomplishment-entity__description Sans-15px-black-70%\"&gt;The World Government Summit Organization has selected ‘REFUGEES’ to be showcased at the event. The documentary will be used to generate awareness in a unique and creative way.&lt;/p&gt;
The World Government Summit Organization is a non-profit, non-government entity focusing on shaping a better future for citizens across the world by empowering governments with knowledge and creating partnerships. This annual summit brings together over 3,000 leaders from both the public and private sector, coming from more than 130 countries.
&lt;h4 class=\"pv-accomplishment-entity__title\"&gt;Official selection for VAULT FILM FESTIVAL, U.K&lt;/h4&gt;
&lt;p class=\"pv-accomplishment-entity__subtitle\"&gt;&lt;span class=\"pv-accomplishment-entity__issuer\"&gt;VAULT FILM FESTIVAL&lt;/span&gt;&lt;/p&gt;
&lt;p class=\"pv-accomplishment-entity__description Sans-15px-black-70%\"&gt;\"Refugees\" was selected in the category of best short documentary.&lt;/p&gt;

&lt;h4 class=\"pv-accomplishment-entity__title\"&gt;Official selection SHIFT FILM FESTIVAL, The Netherland&lt;/h4&gt;
&lt;h4 class=\"pv-accomplishment-entity__title\"&gt;&lt;/h4&gt;
&lt;p class=\"pv-accomplishment-entity__subtitle\"&gt;&lt;span class=\"pv-accomplishment-entity__issuer\"&gt;SHIFT FILM FESTIVAL&lt;/span&gt;&lt;/p&gt;
&lt;p class=\"pv-accomplishment-entity__description Sans-15px-black-70%\"&gt;Shift Film Festival is an audiovisual festival which focuses on the fast and dynamically changing ways in which films are being made and watched.&lt;/p&gt;

&lt;h4 class=\"pv-accomplishment-entity__title\"&gt;Winner Seoul ICARUS Drone International Film Festival, South Korea&lt;/h4&gt;
&lt;p class=\"pv-accomplishment-entity__description Sans-15px-black-70%\"&gt;Prize awarded by the chairman of ICARUS organization committee
Prize awarded by the chairman of ICARUS evaluation committee&lt;/p&gt;

&lt;h4 class=\"pv-accomplishment-entity__title\"&gt;&lt;span class=\"visually-hidden\"&gt;
Auggie Awards&nbsp;&lt;/span&gt;Best Art or Film 2016, U.S.A&lt;/h4&gt;
&lt;p class=\"pv-accomplishment-entity__description Sans-15px-black-70%\"&gt;\"Refugees\" won the Best Art or Film sponsored by the CFC: Art Installations or films including design concepts and documentary films that explore the augmented or virtual world&lt;/p&gt;

&lt;h4 class=\"pv-accomplishment-entity__title\"&gt;Best European Independent Experimental Film 2016, France&lt;/h4&gt;
&lt;p class=\"pv-accomplishment-entity__subtitle\"&gt;&lt;span class=\"pv-accomplishment-entity__issuer\"&gt;&lt;span class=\"visually-hidden\"&gt;&nbsp;&lt;/span&gt;ECU Film Festival 2016 France&lt;/span&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;/div&gt;</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_15][id_base]\" value=\"em_displayrichtext\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_15][name]\" value=\"Richtext Box\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_15][order]\" value=\"10\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_15][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_15][parent]\" value=\"0\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_15][number]\" value=\"15\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>							

10 May 2016

Hello world!

Welcome to WordPress. This is your first post. Edit or delete it, then start writing!

07 Sep 2015

Hello world!

Welcome to Your SUPER-powered WP Engine Multisite Install. This is your first post. Edit or delete it, then start blogging!

02 Mar 2015

Standard Post

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam semper leo eget sapien ultrices vitae facilisis massa dictum. Fusce eu purus a urna accumsan luctus. Nullam sit amet nisi non ante ultrices egestas. Proin erat nulla, congue adipiscing accumsan id, sollicitudin eget dolor. Vestibulum ipsum urna, consequat vel cursus ut, scelerisque vel nisl. Suspendisse molestie facilisis dui, et rutrum enim fermentum id. Curabitur tincidunt tellus sed risus vulputate fringilla. Mauris luctus posuere odio, quis viverra purus consequat ac. Aliquam luctus […]

02 Mar 2015

Self hosted video

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam semper leo eget sapien ultrices vitae facilisis massa dictum. Fusce eu purus a urna accumsan luctus. Nullam sit amet nisi non ante ultrices egestas. Proin erat nulla, congue adipiscing accumsan id, sollicitudin eget dolor. Vestibulum ipsum urna, consequat vel cursus ut, scelerisque vel nisl. Suspendisse molestie facilisis dui, et rutrum enim fermentum id. Curabitur tincidunt tellus sed risus vulputate fringilla. Mauris luctus posuere odio, quis viverra purus consequat ac. Aliquam luctus […]

02 Mar 2015

Audio post

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam semper leo eget sapien ultrices vitae facilisis massa dictum. Fusce eu purus a urna accumsan luctus. Nullam sit amet nisi non ante ultrices egestas. Proin erat nulla, congue adipiscing accumsan id, sollicitudin eget dolor. Vestibulum ipsum urna, consequat vel cursus ut, scelerisque vel nisl. Suspendisse molestie facilisis dui, et rutrum enim fermentum id. Curabitur tincidunt tellus sed risus vulputate fringilla. Mauris luctus posuere odio, quis viverra purus consequat ac. Aliquam luctus […]

02 Mar 2015
Imagination will often carry us to worlds that never were. But without it we go nowhere. — Carl Sagan
02 Mar 2015

Image Lightbox

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam semper leo eget sapien ultrices vitae facilisis massa dictum. Fusce eu purus a urna accumsan luctus. Nullam sit amet nisi non ante ultrices egestas. Proin erat nulla, congue adipiscing accumsan id, sollicitudin eget dolor. Vestibulum ipsum urna, consequat vel cursus ut, scelerisque vel nisl. Suspendisse molestie facilisis dui, et rutrum enim fermentum id. Curabitur tincidunt tellus sed risus vulputate fringilla. Mauris luctus posuere odio, quis viverra purus consequat ac. Aliquam luctus […]

02 Mar 2015

Gallery Post

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam semper leo eget sapien ultrices vitae facilisis massa dictum. Fusce eu purus a urna accumsan luctus. Nullam sit amet nisi non ante ultrices egestas. Proin erat nulla, congue adipiscing accumsan id, sollicitudin eget dolor. Vestibulum ipsum urna, consequat vel cursus ut, scelerisque vel nisl. Suspendisse molestie facilisis dui, et rutrum enim fermentum id. Curabitur tincidunt tellus sed risus vulputate fringilla. Mauris luctus posuere odio, quis viverra purus consequat ac. Aliquam luctus […]

10 Jul 2014

Audio embed

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam semper leo eget sapien ultrices vitae facilisis massa dictum. Fusce eu purus a urna accumsan luctus. Nullam sit amet nisi non ante ultrices egestas. Proin erat nulla, congue adipiscing accumsan id, sollicitudin eget dolor. Vestibulum ipsum urna, consequat vel cursus ut, scelerisque vel nisl. Suspendisse molestie facilisis dui, et rutrum enim fermentum id. Curabitur tincidunt tellus sed risus vulputate fringilla. Mauris luctus posuere odio, quis viverra purus consequat ac. Aliquam luctus […]