
								<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\"></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\"></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=\"forminputdescription\">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=\"forminputdescription\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" type=\"text\" name=\"aq_blocks[aq_block_1][blockNote]\" value=\"\" id=\"blockNote\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_container_type\">Boxed or Fullwidth</label>
							<span class=\"forminputdescription\">
								Boxed or Fullwidth. For full columns
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_1_container_type\" name=\"aq_blocks[aq_block_1][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" 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></div></div></div><h3 class=\"group\">Margin</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_margin_top\">Margin top in pixels</label>
							<span class=\"forminputdescription\">
								Margin top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_1_margin_top\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_1][margin_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"forminputdescription\">
								Margin bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_1_margin_bottom\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_1][margin_bottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><h3 class=\"group\">Padding</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_padding_top\">Padding top in pixels</label>
							<span class=\"forminputdescription\">
								Padding top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">324</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">134</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">124</span></span><input type=\"text\" id=\"aq_block_1_padding_top\" class=\"input-text-full responsive-data-text\" value=\"324,134,124\" name=\"aq_blocks[aq_block_1][padding_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"forminputdescription\">
								Padding bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">56</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">46</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">32</span></span><input type=\"text\" id=\"aq_block_1_padding_bottom\" class=\"input-text-full responsive-data-text\" value=\"56,46,32\" name=\"aq_blocks[aq_block_1][padding_bottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_padding_sidespx\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding both sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_1_padding_sidespx\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_1][padding_sidespx]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_padding_sides\">Padding sides % ( in percentage )</label>
							<span class=\"forminputdescription\">
								Padding both sides in percentage value
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_1_padding_sides\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_1][padding_sides]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><h3 class=\"group\">Background Color</h3><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside 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\" data-alpha=\"false\" class=\"input-color-picker 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-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_gradient_color\">Combine with background color to create Gradients</label>
							<span class=\"forminputdescription\">
								Apply Gradient color
							</span>
						</div><div class=\"formview-rightside 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\" data-alpha=\"false\" class=\"input-color-picker 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-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" 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></div></div></div><h3 class=\"group\">Background Image</h3><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_background_image\">Background Image / Fallback Video Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"https://lasirenapm.com/wp-content/uploads/2018/07/SKY-150x150.png\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_1_background_image_imageid\" name=\"aq_blocks[aq_block_1][background_imageid]\" value=\"13162\"><input type=\"text\" readonly=\"\" id=\"aq_block_1_background_image\" class=\"input-full imagefile-uploader\" value=\"http://lasirenapm.com/wp-content/uploads/2018/07/SKY.png\" 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></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_background_scroll\">Background Properties</label>
							<span class=\"forminputdescription\">
								Background Properties
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_1_background_scroll\" name=\"aq_blocks[aq_block_1][background_scroll]\"><option value=\"static\">Cover</option><option value=\"fit\">Fit</option><option value=\"parallax\" selected=\"selected\">Parallax</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_background_position\">Background Position ( Non Parallax )</label>
							<span class=\"forminputdescription\">
								Background Position ( Non Parallax )
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_1_background_position\" name=\"aq_blocks[aq_block_1][background_position]\"><option value=\"none\" selected=\"selected\">None</option><option value=\"top_left\">Top Left</option><option value=\"top_center\">Top Center</option><option value=\"top_right\">Top Right</option><option value=\"center_left\">Center Left</option><option value=\"center\">Center</option><option value=\"center_right\">Center Right</option><option value=\"bottom_left\">Bottom Left</option><option value=\"bottom_center\">Bottom Center</option><option value=\"bottom_right\">Bottom Right</option></select></div></div></div><h3 class=\"group\">Video</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_video_mp4\">Fill For Video Background - MP4</label>
							<span class=\"forminputdescription\">
								Required : MP4 url.
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_1_video_mp4\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][video_mp4]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_video_webm\">Fill For Video Background - WEBM</label>
							<span class=\"forminputdescription\">
								Required : WEBM url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_1_video_webm\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][video_webm]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_video_ogv\">Fill For Video Background - OGV</label>
							<span class=\"forminputdescription\">
								Required : OGV url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_1_video_ogv\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][video_ogv]\"></div></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-2\" 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-2\" 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-2\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-3\" class=\"block block-em_dividers span2 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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-3\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"3\" 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\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(156,156,156,0.3) 0%, rgba(156,156,156,1) 100%);
background: -webkit-linear-gradient(left, rgba(156,156,156,0.5) 0%,rgba(156,156,156,1) 100%);
background: linear-gradient(to right, rgba(156,156,156,0.5) 0%,rgba(156,156,156,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#9c9c9ca5\', endColorstr=\'#9c9c9ca5\',GradientType=1 );\"><i class=\"fa fa-arrows-v\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Dividers</div><div class=\"block-size\">2/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-3\">						  <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=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_3][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_3][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-3\">
						<div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_mtheme_top\">Top Space in pixels</label>
							<span class=\"forminputdescription\">
								Top Spacing
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">10</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">10</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">10</span></span><input type=\"text\" id=\"aq_block_3_mtheme_top\" class=\"input-text-full responsive-data-text\" value=\"10\" name=\"aq_blocks[aq_block_3][mtheme_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_3][id_base]\" value=\"em_dividers\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_3][name]\" value=\"Dividers\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_3][order]\" value=\"1\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_3][size]\" value=\"span2\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_3][parent]\" value=\"2\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_3][number]\" value=\"3\">				</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-4\" class=\"block block-em_multiheadline span8 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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_multiheadline\" 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: -moz-linear-gradient(left, rgba(225,164,60,0.3) 0%, rgba(225,164,60,1) 100%);
background: -webkit-linear-gradient(left, rgba(225,164,60,0.5) 0%,rgba(225,164,60,1) 100%);
background: linear-gradient(to right, rgba(225,164,60,0.5) 0%,rgba(225,164,60,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#E1A43Ca5\', endColorstr=\'#E1A43Ca5\',GradientType=1 );\"><i class=\"simpleicon-pencil\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Multi Headline</div><div class=\"block-size\">8/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\">Multi Headline</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">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=\"forminputdescription\">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-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_content_richtext\">Multi headline Text</label>
							<span class=\"forminputdescription\">
								Add the content
							</span>
						</div><div class=\"formview-rightside 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\">&lt;h2 style=\"text-align: center;\"&gt;&nbsp;Committed to Serving you&lt;/h2&gt;
&lt;h2 style=\"text-align: center;\"&gt;Providing a Unique&lt;/h2&gt;
&lt;h2 style=\"text-align: center;\"&gt;Quality Dining Experience&lt;/h2&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>

</div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"forminputdescription\">
								Margin bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">38</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">38</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">38</span></span><input type=\"text\" id=\"aq_block_4_mtheme_margin_bottom\" class=\"input-text-full responsive-data-text\" value=\"38\" name=\"aq_blocks[aq_block_4][mtheme_margin_bottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_4][id_base]\" value=\"em_multiheadline\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_4][name]\" value=\"Multi Multi\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_4][order]\" value=\"2\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_4][size]\" value=\"span8\"><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><li id=\"template-block-5\" class=\"block block-em_dividers span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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-5\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"5\" 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\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(156,156,156,0.3) 0%, rgba(156,156,156,1) 100%);
background: -webkit-linear-gradient(left, rgba(156,156,156,0.5) 0%,rgba(156,156,156,1) 100%);
background: linear-gradient(to right, rgba(156,156,156,0.5) 0%,rgba(156,156,156,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#9c9c9ca5\', endColorstr=\'#9c9c9ca5\',GradientType=1 );\"><i class=\"fa fa-arrows-v\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Dividers</div><div class=\"block-size\">3/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-5\">						  <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=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_5][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_5][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-5\">
						<div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_top\">Top Space in pixels</label>
							<span class=\"forminputdescription\">
								Top Spacing
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">10</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">10</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">10</span></span><input type=\"text\" id=\"aq_block_5_mtheme_top\" class=\"input-text-full responsive-data-text\" value=\"10\" name=\"aq_blocks[aq_block_5][mtheme_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_5][id_base]\" value=\"em_dividers\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_5][name]\" value=\"Dividers\"><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=\"span3\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_5][parent]\" value=\"2\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_5][number]\" value=\"5\">				</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-6\" class=\"block block-em_displayrichtext span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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_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\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(225,164,60,0.3) 0%, rgba(225,164,60,1) 100%);
background: -webkit-linear-gradient(left, rgba(225,164,60,0.5) 0%,rgba(225,164,60,1) 100%);
background: linear-gradient(to right, rgba(225,164,60,0.5) 0%,rgba(225,164,60,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#E1A43Ca5\', endColorstr=\'#E1A43Ca5\',GradientType=1 );\"><i class=\"simpleicon-pencil\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Richtext Box</div><div class=\"block-size\">6/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\">Richtext Box</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">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=\"forminputdescription\">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\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_6_mtheme_animated\" name=\"aq_blocks[aq_block_6][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeInUpSlight\" selected=\"selected\">fadeInUpSlight</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInSlightLeft\">fadeInLeftSlight</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInSlightRight\">fadeInRightSlight</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option><option value=\"zoomIn\">zoomIn</option><option value=\"zoomInOut\">zoomInOut</option></select></div></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_content_richtext\">Rich Text</label>
							<span class=\"forminputdescription\">
								Add the content
							</span>
						</div><div class=\"formview-rightside 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\">&lt;p style=\"text-align: center;\"&gt;We have the perfect mix. Puerto Morelos, the atmosphere, the drinks, the food. Come to experience &lt;span style=\"color: #ff6600;\"&gt;&lt;strong&gt;La Sirena&lt;/strong&gt;&lt;/span&gt;&lt;/p&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>

</div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_6][id_base]\" value=\"em_displayrichtext\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_6][name]\" value=\"Richtext Box\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_6][order]\" value=\"4\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_6][size]\" value=\"span6\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_6][parent]\" value=\"2\"><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-2\" 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=\"forminputdescription\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" type=\"text\" name=\"aq_blocks[aq_block_2][blockID]\" value=\"\" id=\"blockID\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" type=\"text\" name=\"aq_blocks[aq_block_2][blockNote]\" value=\"\" id=\"blockNote\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_container_type\">Boxed or Fullwidth</label>
							<span class=\"forminputdescription\">
								Boxed or Fullwidth. For full columns
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_2_container_type\" name=\"aq_blocks[aq_block_2][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_2_text_intensity\" name=\"aq_blocks[aq_block_2][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></div></div></div><h3 class=\"group\">Margin</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_margin_top\">Margin top in pixels</label>
							<span class=\"forminputdescription\">
								Margin top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_2_margin_top\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_2][margin_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"forminputdescription\">
								Margin bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_2_margin_bottom\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_2][margin_bottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><h3 class=\"group\">Padding</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_padding_top\">Padding top in pixels</label>
							<span class=\"forminputdescription\">
								Padding top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">128</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">128</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">128</span></span><input type=\"text\" id=\"aq_block_2_padding_top\" class=\"input-text-full responsive-data-text\" value=\"128\" name=\"aq_blocks[aq_block_2][padding_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"forminputdescription\">
								Padding bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">128</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">128</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">128</span></span><input type=\"text\" id=\"aq_block_2_padding_bottom\" class=\"input-text-full responsive-data-text\" value=\"128\" name=\"aq_blocks[aq_block_2][padding_bottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_padding_sidespx\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding both sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_2_padding_sidespx\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_2][padding_sidespx]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_padding_sides\">Padding sides % ( in percentage )</label>
							<span class=\"forminputdescription\">
								Padding both sides in percentage value
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_2_padding_sides\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_2][padding_sides]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><h3 class=\"group\">Background Color</h3><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside 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_2_background_color\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_2][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-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_gradient_color\">Combine with background color to create Gradients</label>
							<span class=\"forminputdescription\">
								Apply Gradient color
							</span>
						</div><div class=\"formview-rightside 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_2_gradient_color\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_2][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-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_2_gradient_angle\" name=\"aq_blocks[aq_block_2][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></div></div></div><h3 class=\"group\">Background Image</h3><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_background_image\">Background Image / Fallback Video Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_2_background_image_imageid\" name=\"aq_blocks[aq_block_2][background_imageid]\" value=\"\"><input type=\"text\" readonly=\"\" id=\"aq_block_2_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_2][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></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_background_scroll\">Background Properties</label>
							<span class=\"forminputdescription\">
								Background Properties
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_2_background_scroll\" name=\"aq_blocks[aq_block_2][background_scroll]\"><option value=\"static\">Cover</option><option value=\"fit\">Fit</option><option value=\"parallax\" selected=\"selected\">Parallax</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_background_position\">Background Position ( Non Parallax )</label>
							<span class=\"forminputdescription\">
								Background Position ( Non Parallax )
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_2_background_position\" name=\"aq_blocks[aq_block_2][background_position]\"><option value=\"none\" selected=\"selected\">None</option><option value=\"top_left\">Top Left</option><option value=\"top_center\">Top Center</option><option value=\"top_right\">Top Right</option><option value=\"center_left\">Center Left</option><option value=\"center\">Center</option><option value=\"center_right\">Center Right</option><option value=\"bottom_left\">Bottom Left</option><option value=\"bottom_center\">Bottom Center</option><option value=\"bottom_right\">Bottom Right</option></select></div></div></div><h3 class=\"group\">Video</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_video_mp4\">Fill For Video Background - MP4</label>
							<span class=\"forminputdescription\">
								Required : MP4 url.
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_2_video_mp4\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_2][video_mp4]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_video_webm\">Fill For Video Background - WEBM</label>
							<span class=\"forminputdescription\">
								Required : WEBM url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_2_video_webm\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_2][video_webm]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_video_ogv\">Fill For Video Background - OGV</label>
							<span class=\"forminputdescription\">
								Required : OGV url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_2_video_ogv\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_2][video_ogv]\"></div></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_2][id_base]\" value=\"em_column_block\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_2][name]\" value=\"Column Container\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_2][order]\" value=\"2\"><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=\"0\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_2][number]\" value=\"2\">				</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_fromtocounter span4 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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_fromtocounter\" 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: -moz-linear-gradient(left, rgba(61,153,112,0.3) 0%, rgba(61,153,112,1) 100%);
background: -webkit-linear-gradient(left, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
background: linear-gradient(to right, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#3D9970a5\', endColorstr=\'#3D9970a5\',GradientType=1 );\"><i class=\"simpleicon-reload\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">From-To Counter</div><div class=\"block-size\">4/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\">From-To Counter</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">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=\"forminputdescription\">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\">
						<h3 class=\"group\">Content</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_8_mtheme_title\" class=\"input-text-full\" value=\"Varieties\" name=\"aq_blocks[aq_block_8][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_description\">Description</label>
							<span class=\"forminputdescription\">
								Description
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_8_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_8_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_8][mtheme_description]\" id=\"aq_block_8_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><h3 class=\"group\">Count</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_to\">Count to</label>
							<span class=\"forminputdescription\">
								Count to
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_8_mtheme_to\" class=\"input-text-full\" value=\"15\" name=\"aq_blocks[aq_block_8][mtheme_to]\"></div></div><h3 class=\"group\">Icon</h3><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_icon\">Select Icon</label>
							<span class=\"forminputdescription\">
								Click an icon to select, click again to deselect
							</span>
						</div><div class=\"formview-rightside fontawesome-iconpicker\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input type=\"hidden\" id=\"aq_block_8_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_8][mtheme_icon]\" value=\"et-icon-wine\"><i class=\"fontawesome_icon preview et-icon-wine\"></i></div></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_iconcolor\">Icon Color</label>
							<span class=\"forminputdescription\">
								Leave blank for default
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(159, 121, 49);\"><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_8_mtheme_iconcolor\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#9f7931\" name=\"aq_blocks[aq_block_8][mtheme_iconcolor]\" 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: 115.01px; top: 128.03px;\"><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, 166, 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(160, 49, 49), rgb(160, 105, 49), rgb(160, 160, 49), rgb(105, 160, 49), rgb(49, 160, 49), rgb(49, 160, 105), rgb(49, 160, 160), rgb(49, 105, 160), rgb(49, 49, 160), rgb(105, 49, 160), rgb(160, 49, 160), rgb(160, 49, 105), rgb(160, 49, 49));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 89.1667%;\"></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></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_8][id_base]\" value=\"em_fromtocounter\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_8][name]\" value=\"From-To Counter\"><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=\"span4\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_8][parent]\" value=\"3\"><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><li id=\"template-block-9\" class=\"block block-em_fromtocounter span4 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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-9\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"9\" data-mblocktype=\"em_fromtocounter\" 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: -moz-linear-gradient(left, rgba(61,153,112,0.3) 0%, rgba(61,153,112,1) 100%);
background: -webkit-linear-gradient(left, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
background: linear-gradient(to right, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#3D9970a5\', endColorstr=\'#3D9970a5\',GradientType=1 );\"><i class=\"simpleicon-reload\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">From-To Counter</div><div class=\"block-size\">4/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-9\">						  <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\">From-To Counter</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_9][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_9][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-9\">
						<h3 class=\"group\">Content</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_9_mtheme_title\" class=\"input-text-full\" value=\"Weddings\" name=\"aq_blocks[aq_block_9][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_description\">Description</label>
							<span class=\"forminputdescription\">
								Description
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_9_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_9_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_9][mtheme_description]\" id=\"aq_block_9_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><h3 class=\"group\">Count</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_to\">Count to</label>
							<span class=\"forminputdescription\">
								Count to
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_9_mtheme_to\" class=\"input-text-full\" value=\"12\" name=\"aq_blocks[aq_block_9][mtheme_to]\"></div></div><h3 class=\"group\">Icon</h3><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_icon\">Select Icon</label>
							<span class=\"forminputdescription\">
								Click an icon to select, click again to deselect
							</span>
						</div><div class=\"formview-rightside fontawesome-iconpicker\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input type=\"hidden\" id=\"aq_block_9_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_9][mtheme_icon]\" value=\"et-icon-heart\"><i class=\"fontawesome_icon preview et-icon-heart\"></i></div></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_iconcolor\">Icon Color</label>
							<span class=\"forminputdescription\">
								Leave blank for default
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(159, 121, 49);\"><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_mtheme_iconcolor\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#9f7931\" name=\"aq_blocks[aq_block_9][mtheme_iconcolor]\" 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: 115.01px; top: 128.03px;\"><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, 166, 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(160, 49, 49), rgb(160, 105, 49), rgb(160, 160, 49), rgb(105, 160, 49), rgb(49, 160, 49), rgb(49, 160, 105), rgb(49, 160, 160), rgb(49, 105, 160), rgb(49, 49, 160), rgb(105, 49, 160), rgb(160, 49, 160), rgb(160, 49, 105), rgb(160, 49, 49));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 89.1667%;\"></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></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_9][id_base]\" value=\"em_fromtocounter\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_9][name]\" value=\"From-To Counter\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_9][order]\" value=\"2\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_9][size]\" value=\"span4\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_9][parent]\" value=\"3\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_9][number]\" value=\"9\">				</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-10\" class=\"block block-em_fromtocounter span4 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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_fromtocounter\" 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: -moz-linear-gradient(left, rgba(61,153,112,0.3) 0%, rgba(61,153,112,1) 100%);
background: -webkit-linear-gradient(left, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
background: linear-gradient(to right, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#3D9970a5\', endColorstr=\'#3D9970a5\',GradientType=1 );\"><i class=\"simpleicon-reload\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">From-To Counter</div><div class=\"block-size\">4/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\">From-To Counter</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">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=\"forminputdescription\">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\">
						<h3 class=\"group\">Content</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_10_mtheme_title\" class=\"input-text-full\" value=\"Tripadvisor reviews\" name=\"aq_blocks[aq_block_10][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_description\">Description</label>
							<span class=\"forminputdescription\">
								Description
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_10_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_10_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_10][mtheme_description]\" id=\"aq_block_10_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><h3 class=\"group\">Count</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_to\">Count to</label>
							<span class=\"forminputdescription\">
								Count to
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_10_mtheme_to\" class=\"input-text-full\" value=\"832\" name=\"aq_blocks[aq_block_10][mtheme_to]\"></div></div><h3 class=\"group\">Icon</h3><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_icon\">Select Icon</label>
							<span class=\"forminputdescription\">
								Click an icon to select, click again to deselect
							</span>
						</div><div class=\"formview-rightside fontawesome-iconpicker\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input type=\"hidden\" id=\"aq_block_10_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_10][mtheme_icon]\" value=\"et-icon-chat\"><i class=\"fontawesome_icon preview et-icon-chat\"></i></div></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_iconcolor\">Icon Color</label>
							<span class=\"forminputdescription\">
								Leave blank for default
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(159, 121, 49);\"><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_10_mtheme_iconcolor\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#9f7931\" name=\"aq_blocks[aq_block_10][mtheme_iconcolor]\" 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: 115.01px; top: 128.03px;\"><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, 166, 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(160, 49, 49), rgb(160, 105, 49), rgb(160, 160, 49), rgb(105, 160, 49), rgb(49, 160, 49), rgb(49, 160, 105), rgb(49, 160, 160), rgb(49, 105, 160), rgb(49, 49, 160), rgb(105, 49, 160), rgb(160, 49, 160), rgb(160, 49, 105), rgb(160, 49, 49));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 89.1667%;\"></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></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_10][id_base]\" value=\"em_fromtocounter\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_10][name]\" value=\"From-To Counter\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_10][order]\" value=\"3\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_10][size]\" value=\"span4\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_10][parent]\" value=\"3\"><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-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=\"forminputdescription\">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=\"forminputdescription\">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\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_container_type\">Boxed or Fullwidth</label>
							<span class=\"forminputdescription\">
								Boxed or Fullwidth. For full columns
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" 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></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" 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></div></div></div><h3 class=\"group\">Margin</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_margin_top\">Margin top in pixels</label>
							<span class=\"forminputdescription\">
								Margin top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_7_margin_top\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_7][margin_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"forminputdescription\">
								Margin bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_7_margin_bottom\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_7][margin_bottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><h3 class=\"group\">Padding</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_padding_top\">Padding top in pixels</label>
							<span class=\"forminputdescription\">
								Padding top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_7_padding_top\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_7][padding_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"forminputdescription\">
								Padding bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">128</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">128</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">128</span></span><input type=\"text\" id=\"aq_block_7_padding_bottom\" class=\"input-text-full responsive-data-text\" value=\"128\" name=\"aq_blocks[aq_block_7][padding_bottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_padding_sidespx\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding both sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_7_padding_sidespx\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_7][padding_sidespx]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_padding_sides\">Padding sides % ( in percentage )</label>
							<span class=\"forminputdescription\">
								Padding both sides in percentage value
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">10</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">10</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">10</span></span><input type=\"text\" id=\"aq_block_7_padding_sides\" class=\"input-text-full responsive-data-text\" value=\"10\" name=\"aq_blocks[aq_block_7][padding_sides]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><h3 class=\"group\">Background Color</h3><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside 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\" data-alpha=\"false\" class=\"input-color-picker 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-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_gradient_color\">Combine with background color to create Gradients</label>
							<span class=\"forminputdescription\">
								Apply Gradient color
							</span>
						</div><div class=\"formview-rightside 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\" data-alpha=\"false\" class=\"input-color-picker 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-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" 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></div></div></div><h3 class=\"group\">Background Image</h3><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_background_image\">Background Image / Fallback Video Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_7_background_image_imageid\" name=\"aq_blocks[aq_block_7][background_imageid]\" value=\"\"><input type=\"text\" readonly=\"\" id=\"aq_block_7_background_image\" class=\"input-full imagefile-uploader\" value=\"\" 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></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_background_scroll\">Background Properties</label>
							<span class=\"forminputdescription\">
								Background Properties
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_7_background_scroll\" name=\"aq_blocks[aq_block_7][background_scroll]\"><option value=\"static\" selected=\"selected\">Cover</option><option value=\"fit\">Fit</option><option value=\"parallax\">Parallax</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_background_position\">Background Position ( Non Parallax )</label>
							<span class=\"forminputdescription\">
								Background Position ( Non Parallax )
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_7_background_position\" name=\"aq_blocks[aq_block_7][background_position]\"><option value=\"none\" selected=\"selected\">None</option><option value=\"top_left\">Top Left</option><option value=\"top_center\">Top Center</option><option value=\"top_right\">Top Right</option><option value=\"center_left\">Center Left</option><option value=\"center\">Center</option><option value=\"center_right\">Center Right</option><option value=\"bottom_left\">Bottom Left</option><option value=\"bottom_center\">Bottom Center</option><option value=\"bottom_right\">Bottom Right</option></select></div></div></div><h3 class=\"group\">Video</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_video_mp4\">Fill For Video Background - MP4</label>
							<span class=\"forminputdescription\">
								Required : MP4 url.
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_7_video_mp4\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_7][video_mp4]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_video_webm\">Fill For Video Background - WEBM</label>
							<span class=\"forminputdescription\">
								Required : WEBM url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_7_video_webm\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_7][video_webm]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_video_ogv\">Fill For Video Background - OGV</label>
							<span class=\"forminputdescription\">
								Required : OGV url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_7_video_ogv\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_7][video_ogv]\"></div></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=\"3\"><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-11\" 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-11\" 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-11\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-12\" class=\"block block-em_slideshowcarousel span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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_slideshowcarousel\" 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: -moz-linear-gradient(left, rgba(131,105,83,0.3) 0%, rgba(131,105,83,1) 100%);
background: -webkit-linear-gradient(left, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
background: linear-gradient(to right, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#836953a5\', endColorstr=\'#836953a5\',GradientType=1 );\"><i class=\"simpleicon-screen-desktop\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Slideshow</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\">Slideshow</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">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=\"forminputdescription\">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-images\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_pb_image_ids\">Add images</label>
							<span class=\"forminputdescription\">
								Add images
							</span>
						</div><div class=\"formview-rightside images\"><input type=\"hidden\" class=\"mtheme-gallery-selector-ids\" value=\"13169,13168,13167,13166,13165,13163\" name=\"aq_blocks[aq_block_12][mtheme_pb_image_ids]\"><button type=\"button\" class=\"mtheme-gallery-selector\">Select Images</button><div class=\"description\"><ul class=\"mtheme-gallery-selector-list\"><li><img src=\"https://lasirenapm.com/wp-content/uploads/2018/07/6-150x150.png\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://lasirenapm.com/wp-content/uploads/2018/07/5-150x150.png\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://lasirenapm.com/wp-content/uploads/2018/07/3-150x150.png\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://lasirenapm.com/wp-content/uploads/2018/07/2-150x150.png\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://lasirenapm.com/wp-content/uploads/2018/07/1-150x150.png\" width=\"150\" height=\"150\" alt=\"\"></li><li><img src=\"https://lasirenapm.com/wp-content/uploads/2018/07/4-150x150.png\" width=\"150\" height=\"150\" alt=\"\"></li></ul></div></div></div><h3 class=\"group\">Type</h3><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_slideshowtype\">Slideshow type</label>
							<span class=\"forminputdescription\">
								Slideshow type
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_12_mtheme_slideshowtype\" name=\"aq_blocks[aq_block_12][mtheme_slideshowtype]\"><option value=\"slideshow\" selected=\"selected\">Slideshow</option><option value=\"flatcarousel\">2D Center Carousel</option><option value=\"centercarousel\">3D Center Carousel</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_imagesize\">Slideshow image type</label>
							<span class=\"forminputdescription\">
								Slideshow image type
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_12_mtheme_imagesize\" name=\"aq_blocks[aq_block_12][mtheme_imagesize]\"><option value=\"landscape\" selected=\"selected\">Landscape</option><option value=\"portrait\">Portrait</option><option value=\"full\">Full</option></select></div></div></div><h3 class=\"group\">Properties</h3><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_lazyload\">Lazy Load</label>
							<span class=\"forminputdescription\">
								Lazy Load
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_12_mtheme_lazyload\" name=\"aq_blocks[aq_block_12][mtheme_lazyload]\"><option value=\"false\">No</option><option value=\"true\" selected=\"selected\">Yes</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_autoplay\">Autoplay slideshow</label>
							<span class=\"forminputdescription\">
								Autoplay slideshow
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_12_mtheme_autoplay\" name=\"aq_blocks[aq_block_12][mtheme_autoplay]\"><option value=\"false\">No</option><option value=\"true\" selected=\"selected\">Yes</option></select></div></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_autoplayinterval\">Autoplay Interval</label>
							<span class=\"forminputdescription\">
								Autoplay Interval ( 5000 default)
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_12_mtheme_autoplayinterval\" class=\"input-text-full\" value=\"5000\" name=\"aq_blocks[aq_block_12][mtheme_autoplayinterval]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_smartspeed\">Slide Transition</label>
							<span class=\"forminputdescription\">
								Slide Transition ( 1000 default)
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_12_mtheme_smartspeed\" class=\"input-text-full\" value=\"1000\" name=\"aq_blocks[aq_block_12][mtheme_smartspeed]\"></div></div><h3 class=\"group\">Thumbnail</h3><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_lightbox\">Lightbox Activate</label>
							<span class=\"forminputdescription\">
								Lightbox Activate
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_12_mtheme_lightbox\" name=\"aq_blocks[aq_block_12][mtheme_lightbox]\"><option value=\"false\" selected=\"selected\">No</option><option value=\"true\">Yes</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_displaytitle\">Dispay title</label>
							<span class=\"forminputdescription\">
								Display thumbnails
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_12_mtheme_displaytitle\" name=\"aq_blocks[aq_block_12][mtheme_displaytitle]\"><option value=\"true\">Yes</option><option value=\"false\" selected=\"selected\">No</option></select></div></div></div>			
			<input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_12][id_base]\" value=\"em_slideshowcarousel\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_12][name]\" value=\"Slideshow\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_12][order]\" value=\"1\"><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=\"4\"><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></ul><div id=\"my-column-content-11\" 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=\"forminputdescription\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" type=\"text\" name=\"aq_blocks[aq_block_11][blockID]\" value=\"\" id=\"blockID\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" type=\"text\" name=\"aq_blocks[aq_block_11][blockNote]\" value=\"\" id=\"blockNote\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_container_type\">Boxed or Fullwidth</label>
							<span class=\"forminputdescription\">
								Boxed or Fullwidth. For full columns
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_11_container_type\" name=\"aq_blocks[aq_block_11][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_11_text_intensity\" name=\"aq_blocks[aq_block_11][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></div></div></div><h3 class=\"group\">Margin</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_margin_top\">Margin top in pixels</label>
							<span class=\"forminputdescription\">
								Margin top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_11_margin_top\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_11][margin_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"forminputdescription\">
								Margin bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_11_margin_bottom\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_11][margin_bottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><h3 class=\"group\">Padding</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_padding_top\">Padding top in pixels</label>
							<span class=\"forminputdescription\">
								Padding top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_11_padding_top\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_11][padding_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"forminputdescription\">
								Padding bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">128</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">128</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">128</span></span><input type=\"text\" id=\"aq_block_11_padding_bottom\" class=\"input-text-full responsive-data-text\" value=\"128\" name=\"aq_blocks[aq_block_11][padding_bottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_padding_sidespx\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding both sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_11_padding_sidespx\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_11][padding_sidespx]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_padding_sides\">Padding sides % ( in percentage )</label>
							<span class=\"forminputdescription\">
								Padding both sides in percentage value
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_11_padding_sides\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_11][padding_sides]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><h3 class=\"group\">Background Color</h3><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside 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_11_background_color\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_11][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-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_gradient_color\">Combine with background color to create Gradients</label>
							<span class=\"forminputdescription\">
								Apply Gradient color
							</span>
						</div><div class=\"formview-rightside 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_11_gradient_color\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_11][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-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_11_gradient_angle\" name=\"aq_blocks[aq_block_11][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></div></div></div><h3 class=\"group\">Background Image</h3><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_background_image\">Background Image / Fallback Video Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_11_background_image_imageid\" name=\"aq_blocks[aq_block_11][background_imageid]\" value=\"\"><input type=\"text\" readonly=\"\" id=\"aq_block_11_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_11][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></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_background_scroll\">Background Properties</label>
							<span class=\"forminputdescription\">
								Background Properties
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_11_background_scroll\" name=\"aq_blocks[aq_block_11][background_scroll]\"><option value=\"static\" selected=\"selected\">Cover</option><option value=\"fit\">Fit</option><option value=\"parallax\">Parallax</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_background_position\">Background Position ( Non Parallax )</label>
							<span class=\"forminputdescription\">
								Background Position ( Non Parallax )
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_11_background_position\" name=\"aq_blocks[aq_block_11][background_position]\"><option value=\"none\" selected=\"selected\">None</option><option value=\"top_left\">Top Left</option><option value=\"top_center\">Top Center</option><option value=\"top_right\">Top Right</option><option value=\"center_left\">Center Left</option><option value=\"center\">Center</option><option value=\"center_right\">Center Right</option><option value=\"bottom_left\">Bottom Left</option><option value=\"bottom_center\">Bottom Center</option><option value=\"bottom_right\">Bottom Right</option></select></div></div></div><h3 class=\"group\">Video</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_video_mp4\">Fill For Video Background - MP4</label>
							<span class=\"forminputdescription\">
								Required : MP4 url.
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_11_video_mp4\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_11][video_mp4]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_video_webm\">Fill For Video Background - WEBM</label>
							<span class=\"forminputdescription\">
								Required : WEBM url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_11_video_webm\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_11][video_webm]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_video_ogv\">Fill For Video Background - OGV</label>
							<span class=\"forminputdescription\">
								Required : OGV url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_11_video_ogv\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_11][video_ogv]\"></div></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_11][id_base]\" value=\"em_column_block\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_11][name]\" value=\"Column Container\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_11][order]\" value=\"4\"><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=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
		<li id=\"template-block-13\" 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-13\" 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-13\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-14\" class=\"block block-em_sectionheading span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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_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: -moz-linear-gradient(left, rgba(255,105,97,0.3) 0%, rgba(255,105,97,1) 100%);
background: -webkit-linear-gradient(left, rgba(255,105,97,0.5) 0%,rgba(255,105,97,1) 100%);
background: linear-gradient(to right, rgba(255,105,97,0.5) 0%,rgba(255,105,97,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#FF6961a5\', endColorstr=\'#FF6961a5\',GradientType=1 );\"><i class=\"fa fa-header\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><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-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\">Section Heading</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">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=\"forminputdescription\">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-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_14_mtheme_animated\" name=\"aq_blocks[aq_block_14][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeInUpSlight\">fadeInUpSlight</option><option value=\"fadeIn\" selected=\"selected\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInSlightLeft\">fadeInLeftSlight</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInSlightRight\">fadeInRightSlight</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option><option value=\"zoomIn\">zoomIn</option><option value=\"zoomInOut\">zoomInOut</option></select></div></div></div><h3 class=\"group\">Heading</h3><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_headingstyle\">Section style</label>
							<span class=\"forminputdescription\">
								Section style
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_14_mtheme_headingstyle\" name=\"aq_blocks[aq_block_14][mtheme_headingstyle]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"thin\">Medium</option><option value=\"compact\">Compact</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_size\">Heading size</label>
							<span class=\"forminputdescription\">
								Heading size
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_14_mtheme_size\" name=\"aq_blocks[aq_block_14][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></div></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_title\">Section Heading text</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_14_mtheme_title\" class=\"input-text-full\" value=\"Our Services\" name=\"aq_blocks[aq_block_14][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_subtitle\">Section subheading text</label>
							<span class=\"forminputdescription\">
								Section subheading text
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_14_mtheme_subtitle\" class=\"input-text-full\" value=\"Reliable\" name=\"aq_blocks[aq_block_14][mtheme_subtitle]\"></div></div><h3 class=\"group\">Heading Color</h3><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_titlecolor\">Title color</label>
							<span class=\"forminputdescription\">
								Title color
							</span>
						</div><div class=\"formview-rightside 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_14_mtheme_titlecolor\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_titlecolor]\" 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-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_subtitlecolor\">Subtitle color</label>
							<span class=\"forminputdescription\">
								Subtitle color
							</span>
						</div><div class=\"formview-rightside 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_14_mtheme_subtitlecolor\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_subtitlecolor]\" 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-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><h3 class=\"group\">Contents</h3><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_description\">Description (optional)</label>
							<span class=\"forminputdescription\">
								Description text
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_14_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_14_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_14][mtheme_description]\" id=\"aq_block_14_mtheme_description\">We can make a special evening just for you and your loved one. Or maybe a birthday event with a group of friends; Lets us know we make it happen.</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_descstyle\">Description style</label>
							<span class=\"forminputdescription\">
								Description style
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_14_mtheme_descstyle\" name=\"aq_blocks[aq_block_14][mtheme_descstyle]\"><option value=\"none\" selected=\"selected\">None</option><option value=\"fill\">Fill</option><option value=\"boxborder\">Box Border</option><option value=\"bordertop\">Border top</option><option value=\"borderbottom\">Border bottom</option><option value=\"bordertopbottom\">Border top and bottom</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_align\">Align text</label>
							<span class=\"forminputdescription\">
								Align text
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_14_mtheme_align\" name=\"aq_blocks[aq_block_14][mtheme_align]\"><option value=\"center\" selected=\"selected\">Center</option><option value=\"left\">Left</option><option value=\"right\">Right</option></select></div></div></div><h3 class=\"group\">Button</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_14_mtheme_button_text\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_button_text]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_button_url\">Button url</label>
							<span class=\"forminputdescription\">
								Button url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_14_mtheme_button_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_button_url]\"></div></div><h3 class=\"group\">Spacing</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_width\">Width in percent</label>
							<span class=\"forminputdescription\">
								Width in percent
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_14_mtheme_width\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_width]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_titlebottomspace\">Bottom of Title Space</label>
							<span class=\"forminputdescription\">
								Bottom of Title Space in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_14_mtheme_titlebottomspace\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_titlebottomspace]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_top\">Padding Top in pixels</label>
							<span class=\"forminputdescription\">
								Top Spacing
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_14_mtheme_top\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"forminputdescription\">
								Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_14_mtheme_bottom\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_bottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"forminputdescription\">
								Margin Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_14_mtheme_marginbottom\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_marginbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><h3 class=\"group\">Custom Title Size</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_customfontsize\">Custom Title Size in px</label>
							<span class=\"forminputdescription\">
								Custom Title Size in px
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_14_mtheme_customfontsize\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_customfontsize]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_customfontweight\">Custom Title Weight</label>
							<span class=\"forminputdescription\">
								Custom Title Weight ( 100, 200, 300, 400, 500, 600, 700, 800, 900 )
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_14_mtheme_customfontweight\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_customfontweight]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_14][id_base]\" value=\"em_sectionheading\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_14][name]\" value=\"Section Heading\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_14][order]\" value=\"1\"><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=\"5\"><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_serviceboxes span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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_serviceboxes\" 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: -moz-linear-gradient(left, rgba(244,154,194,0.3) 0%, rgba(244,154,194,1) 100%);
background: -webkit-linear-gradient(left, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
background: linear-gradient(to right, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#F49AC2a5\', endColorstr=\'#F49AC2a5\',GradientType=1 );\"><i class=\"simpleicon-note\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Services</div><div class=\"block-size\">3/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\">Services</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">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=\"forminputdescription\">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-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_15_mtheme_animated\" name=\"aq_blocks[aq_block_15][mtheme_animated]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"fadeInUpSlight\">fadeInUpSlight</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInSlightLeft\">fadeInLeftSlight</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInSlightRight\">fadeInRightSlight</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option><option value=\"zoomIn\">zoomIn</option><option value=\"zoomInOut\">zoomInOut</option></select></div></div></div><h3 class=\"group\">Icon</h3><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_icon\">Choose an icon</label>
							<span class=\"forminputdescription\">
								Pick an icon
							</span>
						</div><div class=\"formview-rightside fontawesome-iconpicker\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input type=\"hidden\" id=\"aq_block_15_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_15][mtheme_icon]\" value=\"ion-ios-wineglass-outline\"><i class=\"fontawesome_icon preview ion-ios-wineglass-outline\"></i></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_drawicon\">Animated draw icon</label>
							<span class=\"forminputdescription\">
								Display by drawing the icon.
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_15_mtheme_drawicon\" name=\"aq_blocks[aq_block_15][mtheme_drawicon]\"><option value=\"static\" selected=\"selected\">Static</option><option value=\"draw\">Draw</option></select></div></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_stroke\"><strong>Draw icon stroke width</strong>. Accepts decimals to make it thinner eg. ( 0.5 )</label>
							<span class=\"forminputdescription\">
								Accepts decimals eg. 0.5 or whole numbers to make lines thicker. eg. 2
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_15_mtheme_stroke\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_15][mtheme_stroke]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_iconscale\">Icon Size</label>
							<span class=\"forminputdescription\">
								Icon Size
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_15_mtheme_iconscale\" name=\"aq_blocks[aq_block_15][mtheme_iconscale]\"><option value=\"small\" selected=\"selected\">Small</option><option value=\"large\">Large</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_iconplace\">Icon Placement</label>
							<span class=\"forminputdescription\">
								Placement of icon
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_15_mtheme_iconplace\" name=\"aq_blocks[aq_block_15][mtheme_iconplace]\"><option value=\"top\" selected=\"selected\">Top</option><option value=\"left\">Left</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_iconborder\">Icon Border</label>
							<span class=\"forminputdescription\">
								Placement of service boxes
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_15_mtheme_iconborder\" name=\"aq_blocks[aq_block_15][mtheme_iconborder]\"><option value=\"false\" selected=\"selected\">Disable</option><option value=\"true\">Enable</option></select></div></div></div><h3 class=\"group\">Color</h3><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_iconcolor\">Icon color</label>
							<span class=\"forminputdescription\">
								Color of icon in hex
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(150, 130, 80);\"><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_15_mtheme_iconcolor\" data-alpha=\"true\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#968250\" name=\"aq_blocks[aq_block_15][mtheme_iconcolor]\" 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: 65.1px; top: 119.35px;\"><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, 183, 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(149, 80, 80), rgb(149, 115, 80), rgb(149, 149, 80), rgb(115, 149, 80), rgb(80, 149, 80), rgb(80, 149, 115), rgb(80, 149, 149), rgb(80, 115, 149), rgb(80, 80, 149), rgb(115, 80, 149), rgb(149, 80, 149), rgb(149, 80, 115), rgb(149, 80, 80));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 88.0556%;\"></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></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_iconbackground\">Icon background color</label>
							<span class=\"forminputdescription\">
								Background color of icon
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(255, 255, 255);\"><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_15_mtheme_iconbackground\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#ffffff\" name=\"aq_blocks[aq_block_15][mtheme_iconbackground]\" 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: 0px;\"><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(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><h3 class=\"group\">Link</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_link\">Link</label>
							<span class=\"forminputdescription\">
								Link to title
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_15_mtheme_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_15][mtheme_link]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_linktext\">Text for link</label>
							<span class=\"forminputdescription\">
								Text for link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_15_mtheme_linktext\" class=\"input-text-full\" value=\"Learn more\" name=\"aq_blocks[aq_block_15][mtheme_linktext]\"></div></div><h3 class=\"group\">Content</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_title\">Service Title</label>
							<span class=\"forminputdescription\">
								Title of the service
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_15_mtheme_title\" class=\"input-text-full\" value=\"Dine In\" name=\"aq_blocks[aq_block_15][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_content\">Service Content</label>
							<span class=\"forminputdescription\">
								Add the service content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_15_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_15_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_15][mtheme_content]\" id=\"aq_block_15_mtheme_content\">Come upstairs and choose your table or setting, we plenty of space.</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_15][id_base]\" value=\"em_serviceboxes\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_15][name]\" value=\"Services\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_15][order]\" value=\"2\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_15][size]\" value=\"span3\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_15][parent]\" value=\"5\"><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><li id=\"template-block-16\" class=\"block block-em_serviceboxes span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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-16\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"16\" data-mblocktype=\"em_serviceboxes\" 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: -moz-linear-gradient(left, rgba(244,154,194,0.3) 0%, rgba(244,154,194,1) 100%);
background: -webkit-linear-gradient(left, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
background: linear-gradient(to right, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#F49AC2a5\', endColorstr=\'#F49AC2a5\',GradientType=1 );\"><i class=\"simpleicon-note\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Services</div><div class=\"block-size\">3/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-16\">						  <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\">Services</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_16][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_16][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-16\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_16_mtheme_animated\" name=\"aq_blocks[aq_block_16][mtheme_animated]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"fadeInUpSlight\">fadeInUpSlight</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInSlightLeft\">fadeInLeftSlight</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInSlightRight\">fadeInRightSlight</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option><option value=\"zoomIn\">zoomIn</option><option value=\"zoomInOut\">zoomInOut</option></select></div></div></div><h3 class=\"group\">Icon</h3><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_icon\">Choose an icon</label>
							<span class=\"forminputdescription\">
								Pick an icon
							</span>
						</div><div class=\"formview-rightside fontawesome-iconpicker\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input type=\"hidden\" id=\"aq_block_16_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_16][mtheme_icon]\" value=\"ion-ios-person-outline\"><i class=\"fontawesome_icon preview ion-ios-person-outline\"></i></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_drawicon\">Animated draw icon</label>
							<span class=\"forminputdescription\">
								Display by drawing the icon.
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_16_mtheme_drawicon\" name=\"aq_blocks[aq_block_16][mtheme_drawicon]\"><option value=\"static\" selected=\"selected\">Static</option><option value=\"draw\">Draw</option></select></div></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_stroke\"><strong>Draw icon stroke width</strong>. Accepts decimals to make it thinner eg. ( 0.5 )</label>
							<span class=\"forminputdescription\">
								Accepts decimals eg. 0.5 or whole numbers to make lines thicker. eg. 2
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_16_mtheme_stroke\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_16][mtheme_stroke]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_iconscale\">Icon Size</label>
							<span class=\"forminputdescription\">
								Icon Size
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_16_mtheme_iconscale\" name=\"aq_blocks[aq_block_16][mtheme_iconscale]\"><option value=\"small\" selected=\"selected\">Small</option><option value=\"large\">Large</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_iconplace\">Icon Placement</label>
							<span class=\"forminputdescription\">
								Placement of icon
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_16_mtheme_iconplace\" name=\"aq_blocks[aq_block_16][mtheme_iconplace]\"><option value=\"top\" selected=\"selected\">Top</option><option value=\"left\">Left</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_iconborder\">Icon Border</label>
							<span class=\"forminputdescription\">
								Placement of service boxes
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_16_mtheme_iconborder\" name=\"aq_blocks[aq_block_16][mtheme_iconborder]\"><option value=\"false\" selected=\"selected\">Disable</option><option value=\"true\">Enable</option></select></div></div></div><h3 class=\"group\">Color</h3><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_iconcolor\">Icon color</label>
							<span class=\"forminputdescription\">
								Color of icon in hex
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(150, 130, 80);\"><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_16_mtheme_iconcolor\" data-alpha=\"true\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#968250\" name=\"aq_blocks[aq_block_16][mtheme_iconcolor]\" 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: 65.1px; top: 119.35px;\"><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, 183, 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(149, 80, 80), rgb(149, 115, 80), rgb(149, 149, 80), rgb(115, 149, 80), rgb(80, 149, 80), rgb(80, 149, 115), rgb(80, 149, 149), rgb(80, 115, 149), rgb(80, 80, 149), rgb(115, 80, 149), rgb(149, 80, 149), rgb(149, 80, 115), rgb(149, 80, 80));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 88.0556%;\"></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></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_iconbackground\">Icon background color</label>
							<span class=\"forminputdescription\">
								Background color of icon
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(255, 255, 255);\"><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_16_mtheme_iconbackground\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#ffffff\" name=\"aq_blocks[aq_block_16][mtheme_iconbackground]\" 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: 0px;\"><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(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><h3 class=\"group\">Link</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_link\">Link</label>
							<span class=\"forminputdescription\">
								Link to title
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_16_mtheme_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_16][mtheme_link]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_linktext\">Text for link</label>
							<span class=\"forminputdescription\">
								Text for link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_16_mtheme_linktext\" class=\"input-text-full\" value=\"Find more\" name=\"aq_blocks[aq_block_16][mtheme_linktext]\"></div></div><h3 class=\"group\">Content</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_title\">Service Title</label>
							<span class=\"forminputdescription\">
								Title of the service
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_16_mtheme_title\" class=\"input-text-full\" value=\"Private Celebration\" name=\"aq_blocks[aq_block_16][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_content\">Service Content</label>
							<span class=\"forminputdescription\">
								Add the service content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_16_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_16_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_16][mtheme_content]\" id=\"aq_block_16_mtheme_content\">No matter the occasion we can prepare something special so everyone can have a good time. With over 100 years of international experience, we can virtually design any style of event and are always looking for the next fun challenge. From weddings to birthdays, from drinking groups to art groups, our versatile team can make anything possible.</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_16][id_base]\" value=\"em_serviceboxes\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_16][name]\" value=\"Services\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_16][order]\" value=\"3\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_16][size]\" value=\"span3\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_16][parent]\" value=\"5\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_16][number]\" value=\"16\">				</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-17\" class=\"block block-em_serviceboxes span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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-17\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"17\" data-mblocktype=\"em_serviceboxes\" 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: -moz-linear-gradient(left, rgba(244,154,194,0.3) 0%, rgba(244,154,194,1) 100%);
background: -webkit-linear-gradient(left, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
background: linear-gradient(to right, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#F49AC2a5\', endColorstr=\'#F49AC2a5\',GradientType=1 );\"><i class=\"simpleicon-note\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Services</div><div class=\"block-size\">3/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-17\">						  <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\">Services</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_17][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_17][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-17\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_17_mtheme_animated\" name=\"aq_blocks[aq_block_17][mtheme_animated]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"fadeInUpSlight\">fadeInUpSlight</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInSlightLeft\">fadeInLeftSlight</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInSlightRight\">fadeInRightSlight</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option><option value=\"zoomIn\">zoomIn</option><option value=\"zoomInOut\">zoomInOut</option></select></div></div></div><h3 class=\"group\">Icon</h3><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_icon\">Choose an icon</label>
							<span class=\"forminputdescription\">
								Pick an icon
							</span>
						</div><div class=\"formview-rightside fontawesome-iconpicker\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input type=\"hidden\" id=\"aq_block_17_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_17][mtheme_icon]\" value=\"ion-ios-heart-outline\"><i class=\"fontawesome_icon preview ion-ios-heart-outline\"></i></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_drawicon\">Animated draw icon</label>
							<span class=\"forminputdescription\">
								Display by drawing the icon.
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_17_mtheme_drawicon\" name=\"aq_blocks[aq_block_17][mtheme_drawicon]\"><option value=\"static\" selected=\"selected\">Static</option><option value=\"draw\">Draw</option></select></div></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_stroke\"><strong>Draw icon stroke width</strong>. Accepts decimals to make it thinner eg. ( 0.5 )</label>
							<span class=\"forminputdescription\">
								Accepts decimals eg. 0.5 or whole numbers to make lines thicker. eg. 2
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_17_mtheme_stroke\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_17][mtheme_stroke]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_iconscale\">Icon Size</label>
							<span class=\"forminputdescription\">
								Icon Size
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_17_mtheme_iconscale\" name=\"aq_blocks[aq_block_17][mtheme_iconscale]\"><option value=\"small\" selected=\"selected\">Small</option><option value=\"large\">Large</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_iconplace\">Icon Placement</label>
							<span class=\"forminputdescription\">
								Placement of icon
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_17_mtheme_iconplace\" name=\"aq_blocks[aq_block_17][mtheme_iconplace]\"><option value=\"top\" selected=\"selected\">Top</option><option value=\"left\">Left</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_iconborder\">Icon Border</label>
							<span class=\"forminputdescription\">
								Placement of service boxes
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_17_mtheme_iconborder\" name=\"aq_blocks[aq_block_17][mtheme_iconborder]\"><option value=\"false\" selected=\"selected\">Disable</option><option value=\"true\">Enable</option></select></div></div></div><h3 class=\"group\">Color</h3><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_iconcolor\">Icon color</label>
							<span class=\"forminputdescription\">
								Color of icon in hex
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(150, 130, 80);\"><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_17_mtheme_iconcolor\" data-alpha=\"true\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#968250\" name=\"aq_blocks[aq_block_17][mtheme_iconcolor]\" 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: 65.1px; top: 119.35px;\"><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, 183, 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(149, 80, 80), rgb(149, 115, 80), rgb(149, 149, 80), rgb(115, 149, 80), rgb(80, 149, 80), rgb(80, 149, 115), rgb(80, 149, 149), rgb(80, 115, 149), rgb(80, 80, 149), rgb(115, 80, 149), rgb(149, 80, 149), rgb(149, 80, 115), rgb(149, 80, 80));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 88.0556%;\"></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></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_iconbackground\">Icon background color</label>
							<span class=\"forminputdescription\">
								Background color of icon
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(255, 255, 255);\"><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_17_mtheme_iconbackground\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#ffffff\" name=\"aq_blocks[aq_block_17][mtheme_iconbackground]\" 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: 0px;\"><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(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><h3 class=\"group\">Link</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_link\">Link</label>
							<span class=\"forminputdescription\">
								Link to title
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_17_mtheme_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_17][mtheme_link]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_linktext\">Text for link</label>
							<span class=\"forminputdescription\">
								Text for link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_17_mtheme_linktext\" class=\"input-text-full\" value=\"Find more\" name=\"aq_blocks[aq_block_17][mtheme_linktext]\"></div></div><h3 class=\"group\">Content</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_title\">Service Title</label>
							<span class=\"forminputdescription\">
								Title of the service
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_17_mtheme_title\" class=\"input-text-full\" value=\"Wedding Service\" name=\"aq_blocks[aq_block_17][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_content\">Service Content</label>
							<span class=\"forminputdescription\">
								Add the service content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_17_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_17_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_17][mtheme_content]\" id=\"aq_block_17_mtheme_content\">We have all the contacts to bring together the best day of your life.&nbsp;We know this day will last a lifetime. Come to celebrate with us.</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_17][id_base]\" value=\"em_serviceboxes\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_17][name]\" value=\"Services\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_17][order]\" value=\"4\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_17][size]\" value=\"span3\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_17][parent]\" value=\"5\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_17][number]\" value=\"17\">				</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-18\" class=\"block block-em_serviceboxes span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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-18\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"18\" data-mblocktype=\"em_serviceboxes\" 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: -moz-linear-gradient(left, rgba(244,154,194,0.3) 0%, rgba(244,154,194,1) 100%);
background: -webkit-linear-gradient(left, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
background: linear-gradient(to right, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#F49AC2a5\', endColorstr=\'#F49AC2a5\',GradientType=1 );\"><i class=\"simpleicon-note\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Services</div><div class=\"block-size\">3/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-18\">						  <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\">Services</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_18][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_18][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-18\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_18_mtheme_animated\" name=\"aq_blocks[aq_block_18][mtheme_animated]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"fadeInUpSlight\">fadeInUpSlight</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInSlightLeft\">fadeInLeftSlight</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInSlightRight\">fadeInRightSlight</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option><option value=\"zoomIn\">zoomIn</option><option value=\"zoomInOut\">zoomInOut</option></select></div></div></div><h3 class=\"group\">Icon</h3><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_icon\">Choose an icon</label>
							<span class=\"forminputdescription\">
								Pick an icon
							</span>
						</div><div class=\"formview-rightside fontawesome-iconpicker\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input type=\"hidden\" id=\"aq_block_18_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_18][mtheme_icon]\" value=\"ion-ios-flag-outline\"><i class=\"fontawesome_icon preview ion-ios-flag-outline\"></i></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_drawicon\">Animated draw icon</label>
							<span class=\"forminputdescription\">
								Display by drawing the icon.
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_18_mtheme_drawicon\" name=\"aq_blocks[aq_block_18][mtheme_drawicon]\"><option value=\"static\" selected=\"selected\">Static</option><option value=\"draw\">Draw</option></select></div></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_stroke\"><strong>Draw icon stroke width</strong>. Accepts decimals to make it thinner eg. ( 0.5 )</label>
							<span class=\"forminputdescription\">
								Accepts decimals eg. 0.5 or whole numbers to make lines thicker. eg. 2
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_18_mtheme_stroke\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_18][mtheme_stroke]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_iconscale\">Icon Size</label>
							<span class=\"forminputdescription\">
								Icon Size
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_18_mtheme_iconscale\" name=\"aq_blocks[aq_block_18][mtheme_iconscale]\"><option value=\"small\" selected=\"selected\">Small</option><option value=\"large\">Large</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_iconplace\">Icon Placement</label>
							<span class=\"forminputdescription\">
								Placement of icon
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_18_mtheme_iconplace\" name=\"aq_blocks[aq_block_18][mtheme_iconplace]\"><option value=\"top\" selected=\"selected\">Top</option><option value=\"left\">Left</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_iconborder\">Icon Border</label>
							<span class=\"forminputdescription\">
								Placement of service boxes
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_18_mtheme_iconborder\" name=\"aq_blocks[aq_block_18][mtheme_iconborder]\"><option value=\"false\" selected=\"selected\">Disable</option><option value=\"true\">Enable</option></select></div></div></div><h3 class=\"group\">Color</h3><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_iconcolor\">Icon color</label>
							<span class=\"forminputdescription\">
								Color of icon in hex
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(150, 130, 80);\"><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_18_mtheme_iconcolor\" data-alpha=\"true\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#968250\" name=\"aq_blocks[aq_block_18][mtheme_iconcolor]\" 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: 65.1px; top: 119.35px;\"><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, 183, 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(149, 80, 80), rgb(149, 115, 80), rgb(149, 149, 80), rgb(115, 149, 80), rgb(80, 149, 80), rgb(80, 149, 115), rgb(80, 149, 149), rgb(80, 115, 149), rgb(80, 80, 149), rgb(115, 80, 149), rgb(149, 80, 149), rgb(149, 80, 115), rgb(149, 80, 80));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 88.0556%;\"></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></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_iconbackground\">Icon background color</label>
							<span class=\"forminputdescription\">
								Background color of icon
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(255, 255, 255);\"><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_18_mtheme_iconbackground\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#ffffff\" name=\"aq_blocks[aq_block_18][mtheme_iconbackground]\" 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: 0px;\"><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(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><h3 class=\"group\">Link</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_link\">Link</label>
							<span class=\"forminputdescription\">
								Link to title
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_18_mtheme_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_18][mtheme_link]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_linktext\">Text for link</label>
							<span class=\"forminputdescription\">
								Text for link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_18_mtheme_linktext\" class=\"input-text-full\" value=\"Find more\" name=\"aq_blocks[aq_block_18][mtheme_linktext]\"></div></div><h3 class=\"group\">Content</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_title\">Service Title</label>
							<span class=\"forminputdescription\">
								Title of the service
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_18_mtheme_title\" class=\"input-text-full\" value=\"Birthday Parties\" name=\"aq_blocks[aq_block_18][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_content\">Service Content</label>
							<span class=\"forminputdescription\">
								Add the service content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_18_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_18_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_18][mtheme_content]\" id=\"aq_block_18_mtheme_content\">Not every day is your birthday, come to La Sirena, we\'ll make it worth it.</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_18][id_base]\" value=\"em_serviceboxes\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_18][name]\" value=\"Services\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_18][order]\" value=\"5\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_18][size]\" value=\"span3\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_18][parent]\" value=\"5\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_18][number]\" value=\"18\">				</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-19\" class=\"block block-em_dividers span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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-19\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"19\" 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\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(156,156,156,0.3) 0%, rgba(156,156,156,1) 100%);
background: -webkit-linear-gradient(left, rgba(156,156,156,0.5) 0%,rgba(156,156,156,1) 100%);
background: linear-gradient(to right, rgba(156,156,156,0.5) 0%,rgba(156,156,156,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#9c9c9ca5\', endColorstr=\'#9c9c9ca5\',GradientType=1 );\"><i class=\"fa fa-arrows-v\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><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-19\">						  <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=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_19][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_19][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-19\">
						<div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_mtheme_top\">Top Space in pixels</label>
							<span class=\"forminputdescription\">
								Top Spacing
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">32</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">32</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">32</span></span><input type=\"text\" id=\"aq_block_19_mtheme_top\" class=\"input-text-full responsive-data-text\" value=\"32\" name=\"aq_blocks[aq_block_19][mtheme_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_19][id_base]\" value=\"em_dividers\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_19][name]\" value=\"Dividers\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_19][order]\" value=\"6\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_19][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_19][parent]\" value=\"5\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_19][number]\" value=\"19\">				</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-20\" class=\"block block-em_serviceboxes span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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-20\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"20\" data-mblocktype=\"em_serviceboxes\" 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: -moz-linear-gradient(left, rgba(244,154,194,0.3) 0%, rgba(244,154,194,1) 100%);
background: -webkit-linear-gradient(left, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
background: linear-gradient(to right, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#F49AC2a5\', endColorstr=\'#F49AC2a5\',GradientType=1 );\"><i class=\"simpleicon-note\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Services</div><div class=\"block-size\">3/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-20\">						  <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\">Services</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_20][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_20][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-20\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_20_mtheme_animated\" name=\"aq_blocks[aq_block_20][mtheme_animated]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"fadeInUpSlight\">fadeInUpSlight</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInSlightLeft\">fadeInLeftSlight</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInSlightRight\">fadeInRightSlight</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option><option value=\"zoomIn\">zoomIn</option><option value=\"zoomInOut\">zoomInOut</option></select></div></div></div><h3 class=\"group\">Icon</h3><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_icon\">Choose an icon</label>
							<span class=\"forminputdescription\">
								Pick an icon
							</span>
						</div><div class=\"formview-rightside fontawesome-iconpicker\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input type=\"hidden\" id=\"aq_block_20_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_20][mtheme_icon]\" value=\"ion-ios-clock-outline\"><i class=\"fontawesome_icon preview ion-ios-clock-outline\"></i></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_drawicon\">Animated draw icon</label>
							<span class=\"forminputdescription\">
								Display by drawing the icon.
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_20_mtheme_drawicon\" name=\"aq_blocks[aq_block_20][mtheme_drawicon]\"><option value=\"static\" selected=\"selected\">Static</option><option value=\"draw\">Draw</option></select></div></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_stroke\"><strong>Draw icon stroke width</strong>. Accepts decimals to make it thinner eg. ( 0.5 )</label>
							<span class=\"forminputdescription\">
								Accepts decimals eg. 0.5 or whole numbers to make lines thicker. eg. 2
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_20_mtheme_stroke\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_20][mtheme_stroke]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_iconscale\">Icon Size</label>
							<span class=\"forminputdescription\">
								Icon Size
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_20_mtheme_iconscale\" name=\"aq_blocks[aq_block_20][mtheme_iconscale]\"><option value=\"small\" selected=\"selected\">Small</option><option value=\"large\">Large</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_iconplace\">Icon Placement</label>
							<span class=\"forminputdescription\">
								Placement of icon
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_20_mtheme_iconplace\" name=\"aq_blocks[aq_block_20][mtheme_iconplace]\"><option value=\"top\" selected=\"selected\">Top</option><option value=\"left\">Left</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_iconborder\">Icon Border</label>
							<span class=\"forminputdescription\">
								Placement of service boxes
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_20_mtheme_iconborder\" name=\"aq_blocks[aq_block_20][mtheme_iconborder]\"><option value=\"false\" selected=\"selected\">Disable</option><option value=\"true\">Enable</option></select></div></div></div><h3 class=\"group\">Color</h3><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_iconcolor\">Icon color</label>
							<span class=\"forminputdescription\">
								Color of icon in hex
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(150, 130, 80);\"><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_20_mtheme_iconcolor\" data-alpha=\"true\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#968250\" name=\"aq_blocks[aq_block_20][mtheme_iconcolor]\" 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: 65.1px; top: 119.35px;\"><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, 183, 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(149, 80, 80), rgb(149, 115, 80), rgb(149, 149, 80), rgb(115, 149, 80), rgb(80, 149, 80), rgb(80, 149, 115), rgb(80, 149, 149), rgb(80, 115, 149), rgb(80, 80, 149), rgb(115, 80, 149), rgb(149, 80, 149), rgb(149, 80, 115), rgb(149, 80, 80));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 88.0556%;\"></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></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_iconbackground\">Icon background color</label>
							<span class=\"forminputdescription\">
								Background color of icon
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(255, 255, 255);\"><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_20_mtheme_iconbackground\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#ffffff\" name=\"aq_blocks[aq_block_20][mtheme_iconbackground]\" 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: 0px;\"><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(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><h3 class=\"group\">Link</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_link\">Link</label>
							<span class=\"forminputdescription\">
								Link to title
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_20_mtheme_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_20][mtheme_link]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_linktext\">Text for link</label>
							<span class=\"forminputdescription\">
								Text for link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_20_mtheme_linktext\" class=\"input-text-full\" value=\"Find more\" name=\"aq_blocks[aq_block_20][mtheme_linktext]\"></div></div><h3 class=\"group\">Content</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_title\">Service Title</label>
							<span class=\"forminputdescription\">
								Title of the service
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_20_mtheme_title\" class=\"input-text-full\" value=\"Quality and Timing\" name=\"aq_blocks[aq_block_20][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_content\">Service Content</label>
							<span class=\"forminputdescription\">
								Add the service content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_20_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_20_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_20][mtheme_content]\" id=\"aq_block_20_mtheme_content\">We retain the highest quality standards and are always getting better. Don\'t believe us, come find out</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_20][id_base]\" value=\"em_serviceboxes\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_20][name]\" value=\"Services\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_20][order]\" value=\"7\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_20][size]\" value=\"span3\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_20][parent]\" value=\"5\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_20][number]\" value=\"20\">				</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-21\" class=\"block block-em_serviceboxes span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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-21\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"21\" data-mblocktype=\"em_serviceboxes\" 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: -moz-linear-gradient(left, rgba(244,154,194,0.3) 0%, rgba(244,154,194,1) 100%);
background: -webkit-linear-gradient(left, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
background: linear-gradient(to right, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#F49AC2a5\', endColorstr=\'#F49AC2a5\',GradientType=1 );\"><i class=\"simpleicon-note\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Services</div><div class=\"block-size\">3/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-21\">						  <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\">Services</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_21][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_21][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-21\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_21_mtheme_animated\" name=\"aq_blocks[aq_block_21][mtheme_animated]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"fadeInUpSlight\">fadeInUpSlight</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInSlightLeft\">fadeInLeftSlight</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInSlightRight\">fadeInRightSlight</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option><option value=\"zoomIn\">zoomIn</option><option value=\"zoomInOut\">zoomInOut</option></select></div></div></div><h3 class=\"group\">Icon</h3><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_icon\">Choose an icon</label>
							<span class=\"forminputdescription\">
								Pick an icon
							</span>
						</div><div class=\"formview-rightside fontawesome-iconpicker\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input type=\"hidden\" id=\"aq_block_21_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_21][mtheme_icon]\" value=\"ion-ios-nutrition-outline\"><i class=\"fontawesome_icon preview ion-ios-nutrition-outline\"></i></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_drawicon\">Animated draw icon</label>
							<span class=\"forminputdescription\">
								Display by drawing the icon.
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_21_mtheme_drawicon\" name=\"aq_blocks[aq_block_21][mtheme_drawicon]\"><option value=\"static\" selected=\"selected\">Static</option><option value=\"draw\">Draw</option></select></div></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_stroke\"><strong>Draw icon stroke width</strong>. Accepts decimals to make it thinner eg. ( 0.5 )</label>
							<span class=\"forminputdescription\">
								Accepts decimals eg. 0.5 or whole numbers to make lines thicker. eg. 2
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_21_mtheme_stroke\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_21][mtheme_stroke]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_iconscale\">Icon Size</label>
							<span class=\"forminputdescription\">
								Icon Size
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_21_mtheme_iconscale\" name=\"aq_blocks[aq_block_21][mtheme_iconscale]\"><option value=\"small\" selected=\"selected\">Small</option><option value=\"large\">Large</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_iconplace\">Icon Placement</label>
							<span class=\"forminputdescription\">
								Placement of icon
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_21_mtheme_iconplace\" name=\"aq_blocks[aq_block_21][mtheme_iconplace]\"><option value=\"top\" selected=\"selected\">Top</option><option value=\"left\">Left</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_iconborder\">Icon Border</label>
							<span class=\"forminputdescription\">
								Placement of service boxes
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_21_mtheme_iconborder\" name=\"aq_blocks[aq_block_21][mtheme_iconborder]\"><option value=\"false\" selected=\"selected\">Disable</option><option value=\"true\">Enable</option></select></div></div></div><h3 class=\"group\">Color</h3><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_iconcolor\">Icon color</label>
							<span class=\"forminputdescription\">
								Color of icon in hex
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(150, 130, 80);\"><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_21_mtheme_iconcolor\" data-alpha=\"true\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#968250\" name=\"aq_blocks[aq_block_21][mtheme_iconcolor]\" 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: 65.1px; top: 119.35px;\"><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, 183, 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(149, 80, 80), rgb(149, 115, 80), rgb(149, 149, 80), rgb(115, 149, 80), rgb(80, 149, 80), rgb(80, 149, 115), rgb(80, 149, 149), rgb(80, 115, 149), rgb(80, 80, 149), rgb(115, 80, 149), rgb(149, 80, 149), rgb(149, 80, 115), rgb(149, 80, 80));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 88.0556%;\"></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></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_iconbackground\">Icon background color</label>
							<span class=\"forminputdescription\">
								Background color of icon
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(255, 255, 255);\"><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_21_mtheme_iconbackground\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#ffffff\" name=\"aq_blocks[aq_block_21][mtheme_iconbackground]\" 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: 0px;\"><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(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><h3 class=\"group\">Link</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_link\">Link</label>
							<span class=\"forminputdescription\">
								Link to title
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_21_mtheme_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_21][mtheme_link]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_linktext\">Text for link</label>
							<span class=\"forminputdescription\">
								Text for link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_21_mtheme_linktext\" class=\"input-text-full\" value=\"Find more\" name=\"aq_blocks[aq_block_21][mtheme_linktext]\"></div></div><h3 class=\"group\">Content</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_title\">Service Title</label>
							<span class=\"forminputdescription\">
								Title of the service
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_21_mtheme_title\" class=\"input-text-full\" value=\"Monthly BBQ\" name=\"aq_blocks[aq_block_21][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_content\">Service Content</label>
							<span class=\"forminputdescription\">
								Add the service content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_21_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_21_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_21][mtheme_content]\" id=\"aq_block_21_mtheme_content\">We all love to BBQ, and because of that, we have every month our Special BBQ follow us for the latest on our Club La Sirena Facebook page (shhhh it\'s sort of&nbsp; secret).</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_21][id_base]\" value=\"em_serviceboxes\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_21][name]\" value=\"Services\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_21][order]\" value=\"8\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_21][size]\" value=\"span3\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_21][parent]\" value=\"5\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_21][number]\" value=\"21\">				</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-22\" class=\"block block-em_serviceboxes span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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-22\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"22\" data-mblocktype=\"em_serviceboxes\" 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: -moz-linear-gradient(left, rgba(244,154,194,0.3) 0%, rgba(244,154,194,1) 100%);
background: -webkit-linear-gradient(left, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
background: linear-gradient(to right, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#F49AC2a5\', endColorstr=\'#F49AC2a5\',GradientType=1 );\"><i class=\"simpleicon-note\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Services</div><div class=\"block-size\">3/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-22\">						  <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\">Services</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_22][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_22][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-22\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_22_mtheme_animated\" name=\"aq_blocks[aq_block_22][mtheme_animated]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"fadeInUpSlight\">fadeInUpSlight</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInSlightLeft\">fadeInLeftSlight</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInSlightRight\">fadeInRightSlight</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option><option value=\"zoomIn\">zoomIn</option><option value=\"zoomInOut\">zoomInOut</option></select></div></div></div><h3 class=\"group\">Icon</h3><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_icon\">Choose an icon</label>
							<span class=\"forminputdescription\">
								Pick an icon
							</span>
						</div><div class=\"formview-rightside fontawesome-iconpicker\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input type=\"hidden\" id=\"aq_block_22_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_22][mtheme_icon]\" value=\"ion-ios-lightbulb-outline\"><i class=\"fontawesome_icon preview ion-ios-lightbulb-outline\"></i></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_drawicon\">Animated draw icon</label>
							<span class=\"forminputdescription\">
								Display by drawing the icon.
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_22_mtheme_drawicon\" name=\"aq_blocks[aq_block_22][mtheme_drawicon]\"><option value=\"static\" selected=\"selected\">Static</option><option value=\"draw\">Draw</option></select></div></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_stroke\"><strong>Draw icon stroke width</strong>. Accepts decimals to make it thinner eg. ( 0.5 )</label>
							<span class=\"forminputdescription\">
								Accepts decimals eg. 0.5 or whole numbers to make lines thicker. eg. 2
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_22_mtheme_stroke\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_22][mtheme_stroke]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_iconscale\">Icon Size</label>
							<span class=\"forminputdescription\">
								Icon Size
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_22_mtheme_iconscale\" name=\"aq_blocks[aq_block_22][mtheme_iconscale]\"><option value=\"small\" selected=\"selected\">Small</option><option value=\"large\">Large</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_iconplace\">Icon Placement</label>
							<span class=\"forminputdescription\">
								Placement of icon
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_22_mtheme_iconplace\" name=\"aq_blocks[aq_block_22][mtheme_iconplace]\"><option value=\"top\" selected=\"selected\">Top</option><option value=\"left\">Left</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_iconborder\">Icon Border</label>
							<span class=\"forminputdescription\">
								Placement of service boxes
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_22_mtheme_iconborder\" name=\"aq_blocks[aq_block_22][mtheme_iconborder]\"><option value=\"false\" selected=\"selected\">Disable</option><option value=\"true\">Enable</option></select></div></div></div><h3 class=\"group\">Color</h3><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_iconcolor\">Icon color</label>
							<span class=\"forminputdescription\">
								Color of icon in hex
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(150, 130, 80);\"><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_22_mtheme_iconcolor\" data-alpha=\"true\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#968250\" name=\"aq_blocks[aq_block_22][mtheme_iconcolor]\" 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: 65.1px; top: 119.35px;\"><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, 183, 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(149, 80, 80), rgb(149, 115, 80), rgb(149, 149, 80), rgb(115, 149, 80), rgb(80, 149, 80), rgb(80, 149, 115), rgb(80, 149, 149), rgb(80, 115, 149), rgb(80, 80, 149), rgb(115, 80, 149), rgb(149, 80, 149), rgb(149, 80, 115), rgb(149, 80, 80));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 88.0556%;\"></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></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_iconbackground\">Icon background color</label>
							<span class=\"forminputdescription\">
								Background color of icon
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(255, 255, 255);\"><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_22_mtheme_iconbackground\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#ffffff\" name=\"aq_blocks[aq_block_22][mtheme_iconbackground]\" 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: 0px;\"><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(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><h3 class=\"group\">Link</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_link\">Link</label>
							<span class=\"forminputdescription\">
								Link to title
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_22_mtheme_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_22][mtheme_link]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_linktext\">Text for link</label>
							<span class=\"forminputdescription\">
								Text for link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_22_mtheme_linktext\" class=\"input-text-full\" value=\"Find more\" name=\"aq_blocks[aq_block_22][mtheme_linktext]\"></div></div><h3 class=\"group\">Content</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_title\">Service Title</label>
							<span class=\"forminputdescription\">
								Title of the service
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_22_mtheme_title\" class=\"input-text-full\" value=\"Corporate Events\" name=\"aq_blocks[aq_block_22][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_content\">Service Content</label>
							<span class=\"forminputdescription\">
								Add the service content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_22_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_22_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_22][mtheme_content]\" id=\"aq_block_22_mtheme_content\">Trying to impress your client? Come with us, we help you make a good impression. We have the projector, the coffee, the cakes... just bring your game to seal the deal.</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_22][id_base]\" value=\"em_serviceboxes\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_22][name]\" value=\"Services\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_22][order]\" value=\"9\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_22][size]\" value=\"span3\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_22][parent]\" value=\"5\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_22][number]\" value=\"22\">				</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-23\" class=\"block block-em_serviceboxes span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" 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-23\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"23\" data-mblocktype=\"em_serviceboxes\" 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: -moz-linear-gradient(left, rgba(244,154,194,0.3) 0%, rgba(244,154,194,1) 100%);
background: -webkit-linear-gradient(left, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
background: linear-gradient(to right, rgba(244,154,194,0.5) 0%,rgba(244,154,194,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#F49AC2a5\', endColorstr=\'#F49AC2a5\',GradientType=1 );\"><i class=\"simpleicon-note\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Services</div><div class=\"block-size\">3/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-23\">						  <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\">Services</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_23][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_23][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-23\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_23_mtheme_animated\" name=\"aq_blocks[aq_block_23][mtheme_animated]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"fadeInUpSlight\">fadeInUpSlight</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInSlightLeft\">fadeInLeftSlight</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInSlightRight\">fadeInRightSlight</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option><option value=\"zoomIn\">zoomIn</option><option value=\"zoomInOut\">zoomInOut</option></select></div></div></div><h3 class=\"group\">Icon</h3><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_icon\">Choose an icon</label>
							<span class=\"forminputdescription\">
								Pick an icon
							</span>
						</div><div class=\"formview-rightside fontawesome-iconpicker\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input type=\"hidden\" id=\"aq_block_23_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_23][mtheme_icon]\" value=\"ion-ios-cloudy-night-outline\"><i class=\"fontawesome_icon preview ion-ios-cloudy-night-outline\"></i></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_drawicon\">Animated draw icon</label>
							<span class=\"forminputdescription\">
								Display by drawing the icon.
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_23_mtheme_drawicon\" name=\"aq_blocks[aq_block_23][mtheme_drawicon]\"><option value=\"static\" selected=\"selected\">Static</option><option value=\"draw\">Draw</option></select></div></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_stroke\"><strong>Draw icon stroke width</strong>. Accepts decimals to make it thinner eg. ( 0.5 )</label>
							<span class=\"forminputdescription\">
								Accepts decimals eg. 0.5 or whole numbers to make lines thicker. eg. 2
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_23_mtheme_stroke\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_23][mtheme_stroke]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_iconscale\">Icon Size</label>
							<span class=\"forminputdescription\">
								Icon Size
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_23_mtheme_iconscale\" name=\"aq_blocks[aq_block_23][mtheme_iconscale]\"><option value=\"small\" selected=\"selected\">Small</option><option value=\"large\">Large</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_iconplace\">Icon Placement</label>
							<span class=\"forminputdescription\">
								Placement of icon
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_23_mtheme_iconplace\" name=\"aq_blocks[aq_block_23][mtheme_iconplace]\"><option value=\"top\" selected=\"selected\">Top</option><option value=\"left\">Left</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_iconborder\">Icon Border</label>
							<span class=\"forminputdescription\">
								Placement of service boxes
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_23_mtheme_iconborder\" name=\"aq_blocks[aq_block_23][mtheme_iconborder]\"><option value=\"false\" selected=\"selected\">Disable</option><option value=\"true\">Enable</option></select></div></div></div><h3 class=\"group\">Color</h3><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_iconcolor\">Icon color</label>
							<span class=\"forminputdescription\">
								Color of icon in hex
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(150, 130, 80);\"><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_23_mtheme_iconcolor\" data-alpha=\"true\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#968250\" name=\"aq_blocks[aq_block_23][mtheme_iconcolor]\" 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: 65.1px; top: 119.35px;\"><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, 183, 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(149, 80, 80), rgb(149, 115, 80), rgb(149, 149, 80), rgb(115, 149, 80), rgb(80, 149, 80), rgb(80, 149, 115), rgb(80, 149, 149), rgb(80, 115, 149), rgb(80, 80, 149), rgb(115, 80, 149), rgb(149, 80, 149), rgb(149, 80, 115), rgb(149, 80, 80));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 88.0556%;\"></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></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_iconbackground\">Icon background color</label>
							<span class=\"forminputdescription\">
								Background color of icon
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(255, 255, 255);\"><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_23_mtheme_iconbackground\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#ffffff\" name=\"aq_blocks[aq_block_23][mtheme_iconbackground]\" 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: 0px;\"><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(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255), rgb(255, 255, 255));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><h3 class=\"group\">Link</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_link\">Link</label>
							<span class=\"forminputdescription\">
								Link to title
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_23_mtheme_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_23][mtheme_link]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_linktext\">Text for link</label>
							<span class=\"forminputdescription\">
								Text for link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_23_mtheme_linktext\" class=\"input-text-full\" value=\"Find more\" name=\"aq_blocks[aq_block_23][mtheme_linktext]\"></div></div><h3 class=\"group\">Content</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_title\">Service Title</label>
							<span class=\"forminputdescription\">
								Title of the service
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_23_mtheme_title\" class=\"input-text-full\" value=\"Early Morning Breakfast\" name=\"aq_blocks[aq_block_23][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_content\">Service Content</label>
							<span class=\"forminputdescription\">
								Add the service content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_23_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_23_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_23][mtheme_content]\" id=\"aq_block_23_mtheme_content\">From 7 am till 12 pm daily La Sirena join Richard on our pretty terrace to enjoy local favorites, fresh waffles, potato pancakes and much much more.</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_23][id_base]\" value=\"em_serviceboxes\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_23][name]\" value=\"Services\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_23][order]\" value=\"10\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_23][size]\" value=\"span3\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_23][parent]\" value=\"5\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_23][number]\" value=\"23\">				</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-13\" 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=\"forminputdescription\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" type=\"text\" name=\"aq_blocks[aq_block_13][blockID]\" value=\"\" id=\"blockID\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" type=\"text\" name=\"aq_blocks[aq_block_13][blockNote]\" value=\"\" id=\"blockNote\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_container_type\">Boxed or Fullwidth</label>
							<span class=\"forminputdescription\">
								Boxed or Fullwidth. For full columns
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_13_container_type\" name=\"aq_blocks[aq_block_13][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_13_text_intensity\" name=\"aq_blocks[aq_block_13][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></div></div></div><h3 class=\"group\">Margin</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_margin_top\">Margin top in pixels</label>
							<span class=\"forminputdescription\">
								Margin top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_13_margin_top\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_13][margin_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"forminputdescription\">
								Margin bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_13_margin_bottom\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_13][margin_bottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><h3 class=\"group\">Padding</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_padding_top\">Padding top in pixels</label>
							<span class=\"forminputdescription\">
								Padding top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">128</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">128</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">128</span></span><input type=\"text\" id=\"aq_block_13_padding_top\" class=\"input-text-full responsive-data-text\" value=\"128\" name=\"aq_blocks[aq_block_13][padding_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"forminputdescription\">
								Padding bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">128</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">128</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">128</span></span><input type=\"text\" id=\"aq_block_13_padding_bottom\" class=\"input-text-full responsive-data-text\" value=\"128\" name=\"aq_blocks[aq_block_13][padding_bottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_padding_sidespx\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding both sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_13_padding_sidespx\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_13][padding_sidespx]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_padding_sides\">Padding sides % ( in percentage )</label>
							<span class=\"forminputdescription\">
								Padding both sides in percentage value
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"ion-monitor\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"ion-ipad\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"ion-iphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_13_padding_sides\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_13][padding_sides]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><h3 class=\"group\">Background Color</h3><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\" style=\"background-color: rgb(240, 240, 240);\"><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_13_background_color\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"#f0f0f0\" name=\"aq_blocks[aq_block_13][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: 13.02px;\"><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(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_gradient_color\">Combine with background color to create Gradients</label>
							<span class=\"forminputdescription\">
								Apply Gradient color
							</span>
						</div><div class=\"formview-rightside 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_13_gradient_color\" data-alpha=\"false\" class=\"input-color-picker color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_13][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-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" 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></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_13_gradient_angle\" name=\"aq_blocks[aq_block_13][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></div></div></div><h3 class=\"group\">Background Image</h3><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_background_image\">Background Image / Fallback Video Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_13_background_image_imageid\" name=\"aq_blocks[aq_block_13][background_imageid]\" value=\"\"><input type=\"text\" readonly=\"\" id=\"aq_block_13_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_13][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></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_background_scroll\">Background Properties</label>
							<span class=\"forminputdescription\">
								Background Properties
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_13_background_scroll\" name=\"aq_blocks[aq_block_13][background_scroll]\"><option value=\"static\">Cover</option><option value=\"fit\">Fit</option><option value=\"parallax\" selected=\"selected\">Parallax</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_background_position\">Background Position ( Non Parallax )</label>
							<span class=\"forminputdescription\">
								Background Position ( Non Parallax )
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_13_background_position\" name=\"aq_blocks[aq_block_13][background_position]\"><option value=\"none\" selected=\"selected\">None</option><option value=\"top_left\">Top Left</option><option value=\"top_center\">Top Center</option><option value=\"top_right\">Top Right</option><option value=\"center_left\">Center Left</option><option value=\"center\">Center</option><option value=\"center_right\">Center Right</option><option value=\"bottom_left\">Bottom Left</option><option value=\"bottom_center\">Bottom Center</option><option value=\"bottom_right\">Bottom Right</option></select></div></div></div><h3 class=\"group\">Video</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_video_mp4\">Fill For Video Background - MP4</label>
							<span class=\"forminputdescription\">
								Required : MP4 url.
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_13_video_mp4\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][video_mp4]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_video_webm\">Fill For Video Background - WEBM</label>
							<span class=\"forminputdescription\">
								Required : WEBM url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_13_video_webm\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][video_webm]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_video_ogv\">Fill For Video Background - OGV</label>
							<span class=\"forminputdescription\">
								Required : OGV url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_13_video_ogv\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][video_ogv]\"></div></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_13][id_base]\" value=\"em_column_block\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_13][name]\" value=\"Fullwidth Container\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_13][order]\" value=\"5\"><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=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
									