
								<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\"><li id=\"template-block-2\" 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-2\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"2\" data-mblocktype=\"em_sectionheading\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -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-2\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Section Heading</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_2][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_2][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-2\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_2_mtheme_animated\" name=\"aq_blocks[aq_block_2][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 class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_headingstyle\">Section style</label>
							<span class=\"forminputdescription\">
								Section style
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_2_mtheme_headingstyle\" name=\"aq_blocks[aq_block_2][mtheme_headingstyle]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"compact\">Compact</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_title\">Section Heading text</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_title\" class=\"input-text-full\" value=\"Our Services\" name=\"aq_blocks[aq_block_2][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_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\"><a tabindex=\"0\" class=\"wp-color-result\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_2_mtheme_titlecolor\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_2][mtheme_titlecolor]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_description\">Description (optional)</label>
							<span class=\"forminputdescription\">
								Description text
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_2_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_2_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_2][mtheme_description]\" id=\"aq_block_2_mtheme_description\">Curabitur ac nisl molestie, facilisis nibh ac, facilisis ligula. Integer congue malesuada eros congue varius</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_2_mtheme_descstyle\">Description style</label>
							<span class=\"forminputdescription\">
								Description style
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_2_mtheme_descstyle\" name=\"aq_blocks[aq_block_2][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 class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_align\">Align text</label>
							<span class=\"forminputdescription\">
								Align text
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_2_mtheme_align\" name=\"aq_blocks[aq_block_2][mtheme_align]\"><option value=\"center\">Center</option><option value=\"left\" selected=\"selected\">Left</option><option value=\"right\">Right</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_size\">Heading size</label>
							<span class=\"forminputdescription\">
								Heading size
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_2_mtheme_size\" name=\"aq_blocks[aq_block_2][mtheme_size]\"><option value=\"1\" selected=\"selected\">H1</option><option value=\"2\">H2</option><option value=\"3\">H3</option><option value=\"4\">H4</option><option value=\"5\">H5</option><option value=\"6\">H6</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_customfontsize\">Custom Title Size in px</label>
							<span class=\"forminputdescription\">
								Custom Title Size in px
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_customfontsize\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_2][mtheme_customfontsize]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_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\"><input id=\"aq_block_2_mtheme_customfontweight\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_2][mtheme_customfontweight]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_titlebottomspace\">Bottom of Title Space</label>
							<span class=\"forminputdescription\">
								Bottom of Title Space in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_titlebottomspace\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_2][mtheme_titlebottomspace]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_width\">Width in percent</label>
							<span class=\"forminputdescription\">
								Width in percent
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_width\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_2][mtheme_width]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_top\">Padding Top in pixels</label>
							<span class=\"forminputdescription\">
								Top Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_top\" class=\"input-text-full\" value=\"56\" name=\"aq_blocks[aq_block_2][mtheme_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"forminputdescription\">
								Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_bottom\" class=\"input-text-full\" value=\"0\" name=\"aq_blocks[aq_block_2][mtheme_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"forminputdescription\">
								Margin Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_marginbottom\" class=\"input-text-full\" value=\"0\" name=\"aq_blocks[aq_block_2][mtheme_marginbottom]\" type=\"text\"></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_2][id_base]\" value=\"em_sectionheading\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_2][name]\" value=\"Section Heading\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_2][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_2][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_2][parent]\" value=\"1\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_2][number]\" value=\"2\" type=\"hidden\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li></ul><div id=\"my-column-content-1\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"forminputdescription\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" name=\"aq_blocks[aq_block_1][blockID]\" value=\"\" id=\"blockID\" type=\"text\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" name=\"aq_blocks[aq_block_1][blockNote]\" value=\"\" id=\"blockNote\" type=\"text\">
					  </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\"><select 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 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\"><select id=\"aq_block_1_text_intensity\" name=\"aq_blocks[aq_block_1][text_intensity]\"><option value=\"default\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\" selected=\"selected\">Bright</option></select></div></div><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\"><input id=\"aq_block_1_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][margin_top]\" type=\"text\"></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\"><input id=\"aq_block_1_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][margin_bottom]\" type=\"text\"></div></div><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\"><input id=\"aq_block_1_padding_top\" class=\"input-text-full\" value=\"364\" name=\"aq_blocks[aq_block_1][padding_top]\" type=\"text\"></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\"><input id=\"aq_block_1_padding_bottom\" class=\"input-text-full\" value=\"28\" name=\"aq_blocks[aq_block_1][padding_bottom]\" type=\"text\"></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\"><input id=\"aq_block_1_padding_sidespx\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][padding_sidespx]\" type=\"text\"></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\"><input id=\"aq_block_1_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][padding_sides]\" type=\"text\"></div></div><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\"><a tabindex=\"0\" class=\"wp-color-result\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_1_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_1][background_color]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></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\"><a tabindex=\"0\" class=\"wp-color-result\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_1_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_1][gradient_color]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></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\"><select id=\"aq_block_1_gradient_angle\" name=\"aq_blocks[aq_block_1][gradient_angle]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"to_bottom\">to bottom</option><option value=\"to_top\">to top</option><option value=\"to_top_right\">to top right</option><option value=\"to_top_left\">to top left</option><option value=\"to_bottom_right\">to bottom right</option><option value=\"to_bottom_left\">to bottom left</option></select></div></div><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 id=\"aq_block_1_video_mp4\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][video_mp4]\" type=\"text\"></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 id=\"aq_block_1_video_webm\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][video_webm]\" type=\"text\"></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 id=\"aq_block_1_video_ogv\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][video_ogv]\" type=\"text\"></div></div><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=\"\" alt=\"\">
						<input id=\"aq_block_1_background_image_imageid\" name=\"aq_blocks[aq_block_1][background_imageid]\" value=\"11412\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_1_background_image\" class=\"input-full imagefile-uploader\" value=\"https://dummyimage.com/1400x932/2D5B69/fff.jpg\" name=\"aq_blocks[aq_block_1][background_image]\" type=\"text\"><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\">Scroll effect</label>
							<span class=\"forminputdescription\">
								Scroll effect
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_1_background_scroll\" name=\"aq_blocks[aq_block_1][background_scroll]\"><option value=\"static\">Static</option><option value=\"parallax\" selected=\"selected\">Parallax</option></select></div></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_1][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_1][name]\" value=\"Fullwidth Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_1][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_1][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_1][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_1][number]\" value=\"1\" type=\"hidden\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
		<li id=\"template-block-3\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\">
				<ul class=\"block-controls\">
					<li class=\"block-control-actions cf\">
						<a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove Column Container\"><i class=\"fa fa-trash\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#my-column-content-3\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit Column Container\"><i class=\"fa fa-pencil\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\" data-toggle=\"modal\"><i class=\"fa fa-upload\"></i></a>
					</li>
				</ul>
				<dt class=\"block-handle ui-sortable-handle\">
	 				<div class=\"block-icon\" style=\"color:none;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span>
					<div class=\"blocknote-self\"></div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-3\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-4\" class=\"block block-em_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-4\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"4\" 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-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\">Services</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_4][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_4][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-4\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_4_mtheme_animated\" name=\"aq_blocks[aq_block_4][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 class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_iconplace\">Icon Placement</label>
							<span class=\"forminputdescription\">
								Placement of icon
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_4_mtheme_iconplace\" name=\"aq_blocks[aq_block_4][mtheme_iconplace]\"><option value=\"top\" selected=\"selected\">top</option><option value=\"left\">left</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_iconborder\">iCon Border</label>
							<span class=\"forminputdescription\">
								Placement of service boxes
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_4_mtheme_iconborder\" name=\"aq_blocks[aq_block_4][mtheme_iconborder]\"><option value=\"false\" selected=\"selected\">Disable</option><option value=\"true\">Enable</option></select></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_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\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(0, 0, 0);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_4_mtheme_iconcolor\" class=\"input-color-picker wp-color-picker\" value=\"#000000\" name=\"aq_blocks[aq_block_4][mtheme_iconcolor]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_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\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(249, 249, 249);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_4_mtheme_iconbackground\" class=\"input-color-picker wp-color-picker\" value=\"#f9f9f9\" name=\"aq_blocks[aq_block_4][mtheme_iconbackground]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: 4.34px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_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 id=\"aq_block_4_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_4][mtheme_icon]\" value=\"ion-ios-color-wand-outline\" type=\"hidden\"><i class=\"fontawesome_icon preview ion-ios-color-wand-outline\"></i></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_drawicon\">Animated draw icon</label>
							<span class=\"forminputdescription\">
								Display by drawing the icon
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_4_mtheme_drawicon\" name=\"aq_blocks[aq_block_4][mtheme_drawicon]\"><option value=\"static\" selected=\"selected\">Static</option><option value=\"draw\">Draw</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_iconscale\">Icon Size</label>
							<span class=\"forminputdescription\">
								Icon Size
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_4_mtheme_iconscale\" name=\"aq_blocks[aq_block_4][mtheme_iconscale]\"><option value=\"small\" selected=\"selected\">Small</option><option value=\"large\">Large</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_title\">Service Title</label>
							<span class=\"forminputdescription\">
								Title of the service
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_4_mtheme_title\" class=\"input-text-full\" value=\"Quality\" name=\"aq_blocks[aq_block_4][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_link\">Link</label>
							<span class=\"forminputdescription\">
								Link to title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_4_mtheme_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_4][mtheme_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_linktext\">Text for link</label>
							<span class=\"forminputdescription\">
								Text for link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_4_mtheme_linktext\" class=\"input-text-full\" value=\"Learn more\" name=\"aq_blocks[aq_block_4][mtheme_linktext]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_content\">Service Content</label>
							<span class=\"forminputdescription\">
								Add the service content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_4_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_4_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_4][mtheme_content]\" id=\"aq_block_4_mtheme_content\">Integer posuere erat a ante venenatis dapibus posuere velit aliquet. Cras mattis consectetur purus sit amet fermentum.</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 class=\"id_base\" name=\"aq_blocks[aq_block_4][id_base]\" value=\"em_serviceboxes\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_4][name]\" value=\"Services\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_4][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_4][size]\" value=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_4][parent]\" value=\"2\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_4][number]\" value=\"4\" type=\"hidden\">				</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_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-5\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"5\" 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-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\">Services</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_5][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_5][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-5\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_5_mtheme_animated\" name=\"aq_blocks[aq_block_5][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 class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_iconplace\">Icon Placement</label>
							<span class=\"forminputdescription\">
								Placement of icon
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_5_mtheme_iconplace\" name=\"aq_blocks[aq_block_5][mtheme_iconplace]\"><option value=\"top\" selected=\"selected\">top</option><option value=\"left\">left</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_iconborder\">iCon Border</label>
							<span class=\"forminputdescription\">
								Placement of service boxes
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_5_mtheme_iconborder\" name=\"aq_blocks[aq_block_5][mtheme_iconborder]\"><option value=\"false\" selected=\"selected\">Disable</option><option value=\"true\">Enable</option></select></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_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\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(0, 0, 0);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_5_mtheme_iconcolor\" class=\"input-color-picker wp-color-picker\" value=\"#000000\" name=\"aq_blocks[aq_block_5][mtheme_iconcolor]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_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\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(249, 249, 249);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_5_mtheme_iconbackground\" class=\"input-color-picker wp-color-picker\" value=\"#f9f9f9\" name=\"aq_blocks[aq_block_5][mtheme_iconbackground]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: 4.34px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_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 id=\"aq_block_5_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_5][mtheme_icon]\" value=\"ion-ios-paperplane-outline\" type=\"hidden\"><i class=\"fontawesome_icon preview ion-ios-paperplane-outline\"></i></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_drawicon\">Animated draw icon</label>
							<span class=\"forminputdescription\">
								Display by drawing the icon
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_5_mtheme_drawicon\" name=\"aq_blocks[aq_block_5][mtheme_drawicon]\"><option value=\"static\" selected=\"selected\">Static</option><option value=\"draw\">Draw</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_iconscale\">Icon Size</label>
							<span class=\"forminputdescription\">
								Icon Size
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_5_mtheme_iconscale\" name=\"aq_blocks[aq_block_5][mtheme_iconscale]\"><option value=\"small\" selected=\"selected\">Small</option><option value=\"large\">Large</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_title\">Service Title</label>
							<span class=\"forminputdescription\">
								Title of the service
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_5_mtheme_title\" class=\"input-text-full\" value=\"Experience\" name=\"aq_blocks[aq_block_5][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_link\">Link</label>
							<span class=\"forminputdescription\">
								Link to title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_5_mtheme_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_5][mtheme_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_linktext\">Text for link</label>
							<span class=\"forminputdescription\">
								Text for link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_5_mtheme_linktext\" class=\"input-text-full\" value=\"Find more\" name=\"aq_blocks[aq_block_5][mtheme_linktext]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_content\">Service Content</label>
							<span class=\"forminputdescription\">
								Add the service content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_5_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_5_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_5][mtheme_content]\" id=\"aq_block_5_mtheme_content\">Integer posuere erat a ante venenatis dapibus posuere velit aliquet. Cras mattis consectetur purus sit amet fermentum.</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 class=\"id_base\" name=\"aq_blocks[aq_block_5][id_base]\" value=\"em_serviceboxes\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_5][name]\" value=\"Services\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_5][order]\" value=\"2\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_5][size]\" value=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_5][parent]\" value=\"2\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_5][number]\" value=\"5\" type=\"hidden\">				</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_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-6\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"6\" 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-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\">Services</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_6][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_6][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </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\"><select 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 class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_iconplace\">Icon Placement</label>
							<span class=\"forminputdescription\">
								Placement of icon
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_6_mtheme_iconplace\" name=\"aq_blocks[aq_block_6][mtheme_iconplace]\"><option value=\"top\" selected=\"selected\">top</option><option value=\"left\">left</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_iconborder\">iCon Border</label>
							<span class=\"forminputdescription\">
								Placement of service boxes
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_6_mtheme_iconborder\" name=\"aq_blocks[aq_block_6][mtheme_iconborder]\"><option value=\"false\" selected=\"selected\">Disable</option><option value=\"true\">Enable</option></select></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_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\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(0, 0, 0);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_6_mtheme_iconcolor\" class=\"input-color-picker wp-color-picker\" value=\"#000000\" name=\"aq_blocks[aq_block_6][mtheme_iconcolor]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_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\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(249, 249, 249);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_6_mtheme_iconbackground\" class=\"input-color-picker wp-color-picker\" value=\"#f9f9f9\" name=\"aq_blocks[aq_block_6][mtheme_iconbackground]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: 4.34px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_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 id=\"aq_block_6_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_6][mtheme_icon]\" value=\"ion-ios-settings\" type=\"hidden\"><i class=\"fontawesome_icon preview ion-ios-settings\"></i></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_drawicon\">Animated draw icon</label>
							<span class=\"forminputdescription\">
								Display by drawing the icon
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_6_mtheme_drawicon\" name=\"aq_blocks[aq_block_6][mtheme_drawicon]\"><option value=\"static\" selected=\"selected\">Static</option><option value=\"draw\">Draw</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_iconscale\">Icon Size</label>
							<span class=\"forminputdescription\">
								Icon Size
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_6_mtheme_iconscale\" name=\"aq_blocks[aq_block_6][mtheme_iconscale]\"><option value=\"small\" selected=\"selected\">Small</option><option value=\"large\">Large</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_title\">Service Title</label>
							<span class=\"forminputdescription\">
								Title of the service
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_6_mtheme_title\" class=\"input-text-full\" value=\"Customize\" name=\"aq_blocks[aq_block_6][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_link\">Link</label>
							<span class=\"forminputdescription\">
								Link to title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_6_mtheme_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_6][mtheme_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_linktext\">Text for link</label>
							<span class=\"forminputdescription\">
								Text for link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_6_mtheme_linktext\" class=\"input-text-full\" value=\"Find more\" name=\"aq_blocks[aq_block_6][mtheme_linktext]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_content\">Service Content</label>
							<span class=\"forminputdescription\">
								Add the service content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_6_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_6_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_6][mtheme_content]\" id=\"aq_block_6_mtheme_content\">Integer posuere erat a ante venenatis dapibus posuere velit aliquet. Cras mattis consectetur purus sit amet fermentum.</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 class=\"id_base\" name=\"aq_blocks[aq_block_6][id_base]\" value=\"em_serviceboxes\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_6][name]\" value=\"Services\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_6][order]\" value=\"3\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_6][size]\" value=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_6][parent]\" value=\"2\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_6][number]\" value=\"6\" type=\"hidden\">				</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-7\" 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-7\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"7\" 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-7\">						  <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 name=\"aq_blocks[aq_block_7][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_7][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-7\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_7_mtheme_animated\" name=\"aq_blocks[aq_block_7][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 class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_iconplace\">Icon Placement</label>
							<span class=\"forminputdescription\">
								Placement of icon
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_7_mtheme_iconplace\" name=\"aq_blocks[aq_block_7][mtheme_iconplace]\"><option value=\"top\" selected=\"selected\">top</option><option value=\"left\">left</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_iconborder\">iCon Border</label>
							<span class=\"forminputdescription\">
								Placement of service boxes
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_7_mtheme_iconborder\" name=\"aq_blocks[aq_block_7][mtheme_iconborder]\"><option value=\"false\" selected=\"selected\">Disable</option><option value=\"true\">Enable</option></select></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_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\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(0, 0, 0);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_7_mtheme_iconcolor\" class=\"input-color-picker wp-color-picker\" value=\"#000000\" name=\"aq_blocks[aq_block_7][mtheme_iconcolor]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_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\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(249, 249, 249);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_7_mtheme_iconbackground\" class=\"input-color-picker wp-color-picker\" value=\"#f9f9f9\" name=\"aq_blocks[aq_block_7][mtheme_iconbackground]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: 4.34px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250), rgb(250, 250, 250));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_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 id=\"aq_block_7_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_7][mtheme_icon]\" value=\"ion-ios-lightbulb-outline\" type=\"hidden\"><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_7_mtheme_drawicon\">Animated draw icon</label>
							<span class=\"forminputdescription\">
								Display by drawing the icon
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_7_mtheme_drawicon\" name=\"aq_blocks[aq_block_7][mtheme_drawicon]\"><option value=\"static\" selected=\"selected\">Static</option><option value=\"draw\">Draw</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_iconscale\">Icon Size</label>
							<span class=\"forminputdescription\">
								Icon Size
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_7_mtheme_iconscale\" name=\"aq_blocks[aq_block_7][mtheme_iconscale]\"><option value=\"small\" selected=\"selected\">Small</option><option value=\"large\">Large</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_title\">Service Title</label>
							<span class=\"forminputdescription\">
								Title of the service
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_7_mtheme_title\" class=\"input-text-full\" value=\"Support\" name=\"aq_blocks[aq_block_7][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_link\">Link</label>
							<span class=\"forminputdescription\">
								Link to title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_7_mtheme_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_7][mtheme_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_linktext\">Text for link</label>
							<span class=\"forminputdescription\">
								Text for link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_7_mtheme_linktext\" class=\"input-text-full\" value=\"Find more\" name=\"aq_blocks[aq_block_7][mtheme_linktext]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_content\">Service Content</label>
							<span class=\"forminputdescription\">
								Add the service content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_7_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_7_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_7][mtheme_content]\" id=\"aq_block_7_mtheme_content\">Integer posuere erat a ante venenatis dapibus posuere velit aliquet. Cras mattis consectetur purus sit amet fermentum.</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 class=\"id_base\" name=\"aq_blocks[aq_block_7][id_base]\" value=\"em_serviceboxes\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_7][name]\" value=\"Services\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_7][order]\" value=\"4\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_7][size]\" value=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_7][parent]\" value=\"2\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_7][number]\" value=\"7\" type=\"hidden\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li></ul><div id=\"my-column-content-3\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"forminputdescription\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" name=\"aq_blocks[aq_block_3][blockID]\" value=\"\" id=\"blockID\" type=\"text\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" name=\"aq_blocks[aq_block_3][blockNote]\" value=\"\" id=\"blockNote\" type=\"text\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_container_type\">Boxed or Fullwidth</label>
							<span class=\"forminputdescription\">
								Boxed or Fullwidth. For full columns
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_3_container_type\" name=\"aq_blocks[aq_block_3][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_3_text_intensity\" name=\"aq_blocks[aq_block_3][text_intensity]\"><option value=\"default\">Default</option><option value=\"dark\" selected=\"selected\">Dark</option><option value=\"bright\">Bright</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_margin_top\">Margin top in pixels</label>
							<span class=\"forminputdescription\">
								Margin top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_3_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_3][margin_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"forminputdescription\">
								Margin bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_3_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_3][margin_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_padding_top\">Padding top in pixels</label>
							<span class=\"forminputdescription\">
								Padding top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_3_padding_top\" class=\"input-text-full\" value=\"112\" name=\"aq_blocks[aq_block_3][padding_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"forminputdescription\">
								Padding bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_3_padding_bottom\" class=\"input-text-full\" value=\"86\" name=\"aq_blocks[aq_block_3][padding_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_padding_sidespx\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding both sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_3_padding_sidespx\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_3][padding_sidespx]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_padding_sides\">Padding sides % ( in percentage )</label>
							<span class=\"forminputdescription\">
								Padding both sides in percentage value
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_3_padding_sides\" class=\"input-text-full\" value=\"5\" name=\"aq_blocks[aq_block_3][padding_sides]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_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\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(255, 255, 255);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_3_background_color\" class=\"input-color-picker wp-color-picker\" value=\"#ffffff\" name=\"aq_blocks[aq_block_3][background_color]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center 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-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_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\"><a tabindex=\"0\" class=\"wp-color-result\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_3_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_3][gradient_color]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_3_gradient_angle\" name=\"aq_blocks[aq_block_3][gradient_angle]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"to_bottom\">to bottom</option><option value=\"to_top\">to top</option><option value=\"to_top_right\">to top right</option><option value=\"to_top_left\">to top left</option><option value=\"to_bottom_right\">to bottom right</option><option value=\"to_bottom_left\">to bottom left</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_video_mp4\">Fill For Video Background - MP4</label>
							<span class=\"forminputdescription\">
								Required : MP4 url.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_3_video_mp4\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_3][video_mp4]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_video_webm\">Fill For Video Background - WEBM</label>
							<span class=\"forminputdescription\">
								Required : WEBM url
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_3_video_webm\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_3][video_webm]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_video_ogv\">Fill For Video Background - OGV</label>
							<span class=\"forminputdescription\">
								Required : OGV url
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_3_video_ogv\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_3][video_ogv]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_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 id=\"aq_block_3_background_image_imageid\" name=\"aq_blocks[aq_block_3][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_3_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_3][background_image]\" type=\"text\"><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_3_background_scroll\">Scroll effect</label>
							<span class=\"forminputdescription\">
								Scroll effect
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_3_background_scroll\" name=\"aq_blocks[aq_block_3][background_scroll]\"><option value=\"static\">Static</option><option value=\"parallax\" selected=\"selected\">Parallax</option></select></div></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_3][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_3][name]\" value=\"Fullwidth Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_3][order]\" value=\"2\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_3][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_3][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_3][number]\" value=\"3\" type=\"hidden\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
		<li id=\"template-block-8\" 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-8\" 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-8\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-9\" 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-9\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"9\" 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-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\">Section Heading</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_9][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_9][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-9\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_9_mtheme_animated\" name=\"aq_blocks[aq_block_9][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 class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_headingstyle\">Section style</label>
							<span class=\"forminputdescription\">
								Section style
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_9_mtheme_headingstyle\" name=\"aq_blocks[aq_block_9][mtheme_headingstyle]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"compact\">Compact</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_title\">Section Heading text</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_9_mtheme_title\" class=\"input-text-full\" value=\"Curated Solutions\" name=\"aq_blocks[aq_block_9][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_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\"><a tabindex=\"0\" class=\"wp-color-result\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_9_mtheme_titlecolor\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_9][mtheme_titlecolor]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_description\">Description (optional)</label>
							<span class=\"forminputdescription\">
								Description text
							</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\">Curabitur ac nisl molestie, facilisis nibh ac, facilisis ligula. Integer congue malesuada eros congue varius</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_9_mtheme_descstyle\">Description style</label>
							<span class=\"forminputdescription\">
								Description style
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_9_mtheme_descstyle\" name=\"aq_blocks[aq_block_9][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 class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_align\">Align text</label>
							<span class=\"forminputdescription\">
								Align text
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_9_mtheme_align\" name=\"aq_blocks[aq_block_9][mtheme_align]\"><option value=\"center\" selected=\"selected\">Center</option><option value=\"left\">Left</option><option value=\"right\">Right</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_size\">Heading size</label>
							<span class=\"forminputdescription\">
								Heading size
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_9_mtheme_size\" name=\"aq_blocks[aq_block_9][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 class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_customfontsize\">Custom Title Size in px</label>
							<span class=\"forminputdescription\">
								Custom Title Size in px
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_9_mtheme_customfontsize\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_9][mtheme_customfontsize]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_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\"><input id=\"aq_block_9_mtheme_customfontweight\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_9][mtheme_customfontweight]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_titlebottomspace\">Bottom of Title Space</label>
							<span class=\"forminputdescription\">
								Bottom of Title Space in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_9_mtheme_titlebottomspace\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_9][mtheme_titlebottomspace]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_width\">Width in percent</label>
							<span class=\"forminputdescription\">
								Width in percent
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_9_mtheme_width\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_9][mtheme_width]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_top\">Padding Top in pixels</label>
							<span class=\"forminputdescription\">
								Top Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_9_mtheme_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_9][mtheme_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"forminputdescription\">
								Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_9_mtheme_bottom\" class=\"input-text-full\" value=\"76\" name=\"aq_blocks[aq_block_9][mtheme_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"forminputdescription\">
								Margin Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_9_mtheme_marginbottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_9][mtheme_marginbottom]\" type=\"text\"></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_9][id_base]\" value=\"em_sectionheading\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_9][name]\" value=\"Section Heading\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_9][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_9][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_9][parent]\" value=\"3\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_9][number]\" value=\"9\" type=\"hidden\">				</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_pricingtable 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_pricingtable\" 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(57,204,204,0.3) 0%, rgba(57,204,204,1) 100%);
background: -webkit-linear-gradient(left, rgba(57,204,204,0.5) 0%,rgba(57,204,204,1) 100%);
background: linear-gradient(to right, rgba(57,204,204,0.5) 0%,rgba(57,204,204,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#39CCCCa5\', endColorstr=\'#39CCCCa5\',GradientType=1 );\"><i class=\"fa fa-usd\"></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\">Pricing table</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\">Pricing table</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_10][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_10][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-10\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_10_mtheme_animated\" name=\"aq_blocks[aq_block_10][mtheme_animated]\"><option value=\"none\">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\" selected=\"selected\">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 class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_title\">Column Title</label>
							<span class=\"forminputdescription\">
								Column title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_10_mtheme_title\" class=\"input-text-full\" value=\"Basic Package\" name=\"aq_blocks[aq_block_10][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_title_bgcolor\">Pricing title color</label>
							<span class=\"forminputdescription\">
								Pricing title color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(27, 183, 183);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_10_mtheme_title_bgcolor\" class=\"input-color-picker wp-color-picker\" value=\"#1bb7b7\" name=\"aq_blocks[aq_block_10][mtheme_title_bgcolor]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: 160.58px; top: 128.03px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(0, 255, 255));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(182, 27, 27), rgb(182, 105, 27), rgb(182, 182, 27), rgb(105, 182, 27), rgb(27, 182, 27), rgb(27, 182, 105), rgb(27, 182, 182), rgb(27, 105, 182), rgb(27, 27, 182), rgb(105, 27, 182), rgb(182, 27, 182), rgb(182, 27, 105), rgb(182, 27, 27));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 50%;\"></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_10_mtheme_featured\">Make Featured</label>
							<span class=\"forminputdescription\">
								Make Featured
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_10_mtheme_featured\" name=\"aq_blocks[aq_block_10][mtheme_featured]\"><option value=\"true\" selected=\"selected\">Yes</option><option value=\"false\">No</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_currency\">Currency Symbol</label>
							<span class=\"forminputdescription\">
								Enter currency symbol.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_10_mtheme_currency\" class=\"input-text-full\" value=\"$\" name=\"aq_blocks[aq_block_10][mtheme_currency]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_price\">Price value</label>
							<span class=\"forminputdescription\">
								Enter price value.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_10_mtheme_price\" class=\"input-text-full\" value=\"39.99\" name=\"aq_blocks[aq_block_10][mtheme_price]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_duration\">Enter duration</label>
							<span class=\"forminputdescription\">
								Enter duration.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_10_mtheme_duration\" class=\"input-text-full\" value=\"hour\" name=\"aq_blocks[aq_block_10][mtheme_duration]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_link\">Button link</label>
							<span class=\"forminputdescription\">
								Button link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_10_mtheme_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_10][mtheme_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_10_mtheme_button_text\" class=\"input-text-full\" value=\"Purchase\" name=\"aq_blocks[aq_block_10][mtheme_button_text]\" type=\"text\"></div></div>			
				<ul id=\"aq-sortable-list-aq_block_10\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_10\">
								<li id=\"aq_block_10_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Up to 6 Hours of coverage						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-1-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_10_tabs-1-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_10][tabs][1][row_text]\" value=\"Up to 6 Hours of coverage\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-1-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_10_tabs-1-type\" name=\"aq_blocks[aq_block_10][tabs][1][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_10_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Engagement session						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-2-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_10_tabs-2-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_10][tabs][2][row_text]\" value=\"Engagement session\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-2-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_10_tabs-2-type\" name=\"aq_blocks[aq_block_10][tabs][2][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_10_tabs-sortable-item-3\" class=\"sortable-item ui-sortable-handle\" rel=\"3\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Photo Album						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-3-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_10_tabs-3-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_10][tabs][3][row_text]\" value=\"Photo Album\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-3-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_10_tabs-3-type\" name=\"aq_blocks[aq_block_10][tabs][3][type]\"><option value=\"tick\">Tick</option><option value=\"cross\" selected=\"selected\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_10_tabs-sortable-item-4\" class=\"sortable-item ui-sortable-handle\" rel=\"4\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							20 - 8x10 prints of your...						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-4-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_10_tabs-4-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_10][tabs][4][row_text]\" value=\"20 - 8x10 prints of your choosing\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-4-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_10_tabs-4-type\" name=\"aq_blocks[aq_block_10][tabs][4][type]\"><option value=\"tick\">Tick</option><option value=\"cross\" selected=\"selected\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_10_tabs-sortable-item-5\" class=\"sortable-item ui-sortable-handle\" rel=\"5\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							16x20 gallery wrapped canvas!						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-5-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_10_tabs-5-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_10][tabs][5][row_text]\" value=\"16x20 gallery wrapped canvas!\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-5-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_10_tabs-5-type\" name=\"aq_blocks[aq_block_10][tabs][5][type]\"><option value=\"tick\">Tick</option><option value=\"cross\" selected=\"selected\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_10_tabs-sortable-item-6\" class=\"sortable-item ui-sortable-handle\" rel=\"6\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							High resolution digital images						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-6-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_10_tabs-6-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_10][tabs][6][row_text]\" value=\"High resolution digital images\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-6-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_10_tabs-6-type\" name=\"aq_blocks[aq_block_10][tabs][6][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_10_tabs-sortable-item-7\" class=\"sortable-item ui-sortable-handle\" rel=\"7\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Full rights to prints						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-7-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_10_tabs-7-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_10][tabs][7][row_text]\" value=\"Full rights to prints\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-7-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_10_tabs-7-type\" name=\"aq_blocks[aq_block_10][tabs][7][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_10_tabs-sortable-item-8\" class=\"sortable-item ui-sortable-handle\" rel=\"8\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Free retouching! 						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-8-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_10_tabs-8-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_10][tabs][8][row_text]\" value=\"Free retouching! \" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-8-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_10_tabs-8-type\" name=\"aq_blocks[aq_block_10][tabs][8][type]\"><option value=\"tick\">Tick</option><option value=\"cross\" selected=\"selected\">Cross</option></select></div><p></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"pricing_table\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_10][id_base]\" value=\"em_pricingtable\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_10][name]\" value=\"Pricing table\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_10][order]\" value=\"2\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_10][size]\" value=\"span4\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_10][parent]\" value=\"3\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_10][number]\" value=\"10\" type=\"hidden\">				</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-11\" class=\"block block-em_pricingtable 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-11\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"11\" data-mblocktype=\"em_pricingtable\" 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(57,204,204,0.3) 0%, rgba(57,204,204,1) 100%);
background: -webkit-linear-gradient(left, rgba(57,204,204,0.5) 0%,rgba(57,204,204,1) 100%);
background: linear-gradient(to right, rgba(57,204,204,0.5) 0%,rgba(57,204,204,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#39CCCCa5\', endColorstr=\'#39CCCCa5\',GradientType=1 );\"><i class=\"fa fa-usd\"></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\">Pricing table</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-11\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Pricing table</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_11][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_11][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-11\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_11_mtheme_animated\" name=\"aq_blocks[aq_block_11][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 class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_title\">Column Title</label>
							<span class=\"forminputdescription\">
								Column title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_11_mtheme_title\" class=\"input-text-full\" value=\"Full Package\" name=\"aq_blocks[aq_block_11][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_title_bgcolor\">Pricing title color</label>
							<span class=\"forminputdescription\">
								Pricing title color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(234, 86, 120);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_11_mtheme_title_bgcolor\" class=\"input-color-picker wp-color-picker\" value=\"#ea5678\" name=\"aq_blocks[aq_block_11][mtheme_title_bgcolor]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: 169.26px; top: 80.29px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 59));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(234, 87, 87), rgb(234, 161, 87), rgb(234, 234, 87), rgb(161, 234, 87), rgb(87, 234, 87), rgb(87, 234, 161), rgb(87, 234, 234), rgb(87, 161, 234), rgb(87, 87, 234), rgb(161, 87, 234), rgb(234, 87, 234), rgb(234, 87, 161), rgb(234, 87, 87));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 3.88889%;\"></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_mtheme_featured\">Make Featured</label>
							<span class=\"forminputdescription\">
								Make Featured
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_11_mtheme_featured\" name=\"aq_blocks[aq_block_11][mtheme_featured]\"><option value=\"true\" selected=\"selected\">Yes</option><option value=\"false\">No</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_currency\">Currency Symbol</label>
							<span class=\"forminputdescription\">
								Enter currency symbol.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_11_mtheme_currency\" class=\"input-text-full\" value=\"$\" name=\"aq_blocks[aq_block_11][mtheme_currency]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_price\">Price value</label>
							<span class=\"forminputdescription\">
								Enter price value.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_11_mtheme_price\" class=\"input-text-full\" value=\"89.99\" name=\"aq_blocks[aq_block_11][mtheme_price]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_duration\">Enter duration</label>
							<span class=\"forminputdescription\">
								Enter duration.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_11_mtheme_duration\" class=\"input-text-full\" value=\"hour\" name=\"aq_blocks[aq_block_11][mtheme_duration]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_link\">Button link</label>
							<span class=\"forminputdescription\">
								Button link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_11_mtheme_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_11][mtheme_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_11_mtheme_button_text\" class=\"input-text-full\" value=\"Purchase\" name=\"aq_blocks[aq_block_11][mtheme_button_text]\" type=\"text\"></div></div>			
				<ul id=\"aq-sortable-list-aq_block_11\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_11\">
								<li id=\"aq_block_11_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Up to 6 Hours of coverage						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-1-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_11_tabs-1-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_11][tabs][1][row_text]\" value=\"Up to 6 Hours of coverage\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-1-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_11_tabs-1-type\" name=\"aq_blocks[aq_block_11][tabs][1][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_11_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Engagement session						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-2-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_11_tabs-2-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_11][tabs][2][row_text]\" value=\"Engagement session\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-2-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_11_tabs-2-type\" name=\"aq_blocks[aq_block_11][tabs][2][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_11_tabs-sortable-item-3\" class=\"sortable-item ui-sortable-handle\" rel=\"3\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Photo Album						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-3-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_11_tabs-3-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_11][tabs][3][row_text]\" value=\"Photo Album\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-3-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_11_tabs-3-type\" name=\"aq_blocks[aq_block_11][tabs][3][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_11_tabs-sortable-item-4\" class=\"sortable-item ui-sortable-handle\" rel=\"4\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							20 - 8x10 prints of your...						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-4-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_11_tabs-4-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_11][tabs][4][row_text]\" value=\"20 - 8x10 prints of your choosing\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-4-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_11_tabs-4-type\" name=\"aq_blocks[aq_block_11][tabs][4][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_11_tabs-sortable-item-5\" class=\"sortable-item ui-sortable-handle\" rel=\"5\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							16x20 gallery wrapped canvas!						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-5-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_11_tabs-5-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_11][tabs][5][row_text]\" value=\"16x20 gallery wrapped canvas!\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-5-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_11_tabs-5-type\" name=\"aq_blocks[aq_block_11][tabs][5][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_11_tabs-sortable-item-6\" class=\"sortable-item ui-sortable-handle\" rel=\"6\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							High resolution digital images						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-6-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_11_tabs-6-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_11][tabs][6][row_text]\" value=\"High resolution digital images\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-6-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_11_tabs-6-type\" name=\"aq_blocks[aq_block_11][tabs][6][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_11_tabs-sortable-item-7\" class=\"sortable-item ui-sortable-handle\" rel=\"7\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Full rights to prints						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-7-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_11_tabs-7-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_11][tabs][7][row_text]\" value=\"Full rights to prints\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-7-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_11_tabs-7-type\" name=\"aq_blocks[aq_block_11][tabs][7][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_11_tabs-sortable-item-8\" class=\"sortable-item ui-sortable-handle\" rel=\"8\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Free retouching! 						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-8-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_11_tabs-8-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_11][tabs][8][row_text]\" value=\"Free retouching! \" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_11_tabs-8-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_11_tabs-8-type\" name=\"aq_blocks[aq_block_11][tabs][8][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"pricing_table\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_11][id_base]\" value=\"em_pricingtable\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_11][name]\" value=\"Pricing table\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_11][order]\" value=\"3\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_11][size]\" value=\"span4\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_11][parent]\" value=\"3\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_11][number]\" value=\"11\" type=\"hidden\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-12\" class=\"block block-em_pricingtable 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-12\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"12\" data-mblocktype=\"em_pricingtable\" 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(57,204,204,0.3) 0%, rgba(57,204,204,1) 100%);
background: -webkit-linear-gradient(left, rgba(57,204,204,0.5) 0%,rgba(57,204,204,1) 100%);
background: linear-gradient(to right, rgba(57,204,204,0.5) 0%,rgba(57,204,204,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#39CCCCa5\', endColorstr=\'#39CCCCa5\',GradientType=1 );\"><i class=\"fa fa-usd\"></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\">Pricing table</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-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\">Pricing table</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_12][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_12][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-12\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_12_mtheme_animated\" name=\"aq_blocks[aq_block_12][mtheme_animated]\"><option value=\"none\">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\" selected=\"selected\">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 class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_title\">Column Title</label>
							<span class=\"forminputdescription\">
								Column title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_12_mtheme_title\" class=\"input-text-full\" value=\"Premium Package\" name=\"aq_blocks[aq_block_12][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_title_bgcolor\">Pricing title color</label>
							<span class=\"forminputdescription\">
								Pricing title color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(87, 47, 206);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_12_mtheme_title_bgcolor\" class=\"input-color-picker wp-color-picker\" value=\"#572fce\" name=\"aq_blocks[aq_block_12][mtheme_title_bgcolor]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: 136.71px; top: 108.5px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(64, 0, 255));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(208, 47, 47), rgb(208, 128, 47), rgb(208, 208, 47), rgb(127, 208, 47), rgb(47, 208, 47), rgb(47, 208, 127), rgb(47, 208, 208), rgb(47, 128, 208), rgb(47, 47, 208), rgb(128, 47, 208), rgb(208, 47, 208), rgb(208, 47, 127), rgb(208, 47, 47));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 29.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><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_featured\">Make Featured</label>
							<span class=\"forminputdescription\">
								Make Featured
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_12_mtheme_featured\" name=\"aq_blocks[aq_block_12][mtheme_featured]\"><option value=\"true\" selected=\"selected\">Yes</option><option value=\"false\">No</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_currency\">Currency Symbol</label>
							<span class=\"forminputdescription\">
								Enter currency symbol.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_12_mtheme_currency\" class=\"input-text-full\" value=\"$\" name=\"aq_blocks[aq_block_12][mtheme_currency]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_price\">Price value</label>
							<span class=\"forminputdescription\">
								Enter price value.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_12_mtheme_price\" class=\"input-text-full\" value=\"79.99\" name=\"aq_blocks[aq_block_12][mtheme_price]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_duration\">Enter duration</label>
							<span class=\"forminputdescription\">
								Enter duration.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_12_mtheme_duration\" class=\"input-text-full\" value=\"hour\" name=\"aq_blocks[aq_block_12][mtheme_duration]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_link\">Button link</label>
							<span class=\"forminputdescription\">
								Button link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_12_mtheme_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_12][mtheme_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_12_mtheme_button_text\" class=\"input-text-full\" value=\"Purchase\" name=\"aq_blocks[aq_block_12][mtheme_button_text]\" type=\"text\"></div></div>			
				<ul id=\"aq-sortable-list-aq_block_12\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_12\">
								<li id=\"aq_block_12_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Up to 6 Hours of coverage						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-1-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_12_tabs-1-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_12][tabs][1][row_text]\" value=\"Up to 6 Hours of coverage\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-1-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_12_tabs-1-type\" name=\"aq_blocks[aq_block_12][tabs][1][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_12_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Engagement session						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-2-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_12_tabs-2-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_12][tabs][2][row_text]\" value=\"Engagement session\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-2-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_12_tabs-2-type\" name=\"aq_blocks[aq_block_12][tabs][2][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_12_tabs-sortable-item-3\" class=\"sortable-item ui-sortable-handle\" rel=\"3\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Photo Album						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-3-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_12_tabs-3-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_12][tabs][3][row_text]\" value=\"Photo Album\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-3-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_12_tabs-3-type\" name=\"aq_blocks[aq_block_12][tabs][3][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_12_tabs-sortable-item-4\" class=\"sortable-item ui-sortable-handle\" rel=\"4\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							20 - 8x10 prints of your...						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-4-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_12_tabs-4-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_12][tabs][4][row_text]\" value=\"20 - 8x10 prints of your choosing\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-4-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_12_tabs-4-type\" name=\"aq_blocks[aq_block_12][tabs][4][type]\"><option value=\"tick\">Tick</option><option value=\"cross\" selected=\"selected\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_12_tabs-sortable-item-5\" class=\"sortable-item ui-sortable-handle\" rel=\"5\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							16x20 gallery wrapped canvas!						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-5-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_12_tabs-5-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_12][tabs][5][row_text]\" value=\"16x20 gallery wrapped canvas!\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-5-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_12_tabs-5-type\" name=\"aq_blocks[aq_block_12][tabs][5][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_12_tabs-sortable-item-6\" class=\"sortable-item ui-sortable-handle\" rel=\"6\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							High resolution digital images						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-6-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_12_tabs-6-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_12][tabs][6][row_text]\" value=\"High resolution digital images\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-6-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_12_tabs-6-type\" name=\"aq_blocks[aq_block_12][tabs][6][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_12_tabs-sortable-item-7\" class=\"sortable-item ui-sortable-handle\" rel=\"7\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Full rights to prints						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-7-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_12_tabs-7-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_12][tabs][7][row_text]\" value=\"Full rights to prints\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-7-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_12_tabs-7-type\" name=\"aq_blocks[aq_block_12][tabs][7][type]\"><option value=\"tick\" selected=\"selected\">Tick</option><option value=\"cross\">Cross</option></select></div><p></p>			</div>
		</li>
			<li id=\"aq_block_12_tabs-sortable-item-8\" class=\"sortable-item ui-sortable-handle\" rel=\"8\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Free retouching! 						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-8-row_text\">Row text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_12_tabs-8-row_text\" class=\"input-full\" name=\"aq_blocks[aq_block_12][tabs][8][row_text]\" value=\"Free retouching! \" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_12_tabs-8-type\">Tick or Cross</label>
						</div>
						<div class=\"formview-rightside\"><select id=\"aq_block_12_tabs-8-type\" name=\"aq_blocks[aq_block_12][tabs][8][type]\"><option value=\"tick\">Tick</option><option value=\"cross\" selected=\"selected\">Cross</option></select></div><p></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"pricing_table\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_12][id_base]\" value=\"em_pricingtable\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_12][name]\" value=\"Pricing table\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_12][order]\" value=\"4\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_12][size]\" value=\"span4\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_12][parent]\" value=\"3\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_12][number]\" value=\"12\" type=\"hidden\">				</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-8\" 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\" name=\"aq_blocks[aq_block_8][blockID]\" value=\"\" id=\"blockID\" type=\"text\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" name=\"aq_blocks[aq_block_8][blockNote]\" value=\"\" id=\"blockNote\" type=\"text\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_container_type\">Boxed or Fullwidth</label>
							<span class=\"forminputdescription\">
								Boxed or Fullwidth. For full columns
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_8_container_type\" name=\"aq_blocks[aq_block_8][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_8_text_intensity\" name=\"aq_blocks[aq_block_8][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_margin_top\">Margin top in pixels</label>
							<span class=\"forminputdescription\">
								Margin top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_8_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_8][margin_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"forminputdescription\">
								Margin bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_8_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_8][margin_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_padding_top\">Padding top in pixels</label>
							<span class=\"forminputdescription\">
								Padding top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_8_padding_top\" class=\"input-text-full\" value=\"112\" name=\"aq_blocks[aq_block_8][padding_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"forminputdescription\">
								Padding bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_8_padding_bottom\" class=\"input-text-full\" value=\"112\" name=\"aq_blocks[aq_block_8][padding_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_padding_sidespx\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding both sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_8_padding_sidespx\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_8][padding_sidespx]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_padding_sides\">Padding sides % ( in percentage )</label>
							<span class=\"forminputdescription\">
								Padding both sides in percentage value
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_8_padding_sides\" class=\"input-text-full\" value=\"5\" name=\"aq_blocks[aq_block_8][padding_sides]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_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\"><a tabindex=\"0\" class=\"wp-color-result\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_8_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_8][background_color]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_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\"><a tabindex=\"0\" class=\"wp-color-result\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_8_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_8][gradient_color]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_8_gradient_angle\" name=\"aq_blocks[aq_block_8][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 class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_video_mp4\">Fill For Video Background - MP4</label>
							<span class=\"forminputdescription\">
								Required : MP4 url.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_8_video_mp4\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_8][video_mp4]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_video_webm\">Fill For Video Background - WEBM</label>
							<span class=\"forminputdescription\">
								Required : WEBM url
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_8_video_webm\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_8][video_webm]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_video_ogv\">Fill For Video Background - OGV</label>
							<span class=\"forminputdescription\">
								Required : OGV url
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_8_video_ogv\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_8][video_ogv]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_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 id=\"aq_block_8_background_image_imageid\" name=\"aq_blocks[aq_block_8][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_8_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_8][background_image]\" type=\"text\"><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_8_background_scroll\">Scroll effect</label>
							<span class=\"forminputdescription\">
								Scroll effect
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_8_background_scroll\" name=\"aq_blocks[aq_block_8][background_scroll]\"><option value=\"static\">Static</option><option value=\"parallax\" selected=\"selected\">Parallax</option></select></div></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_8][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_8][name]\" value=\"Column Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_8][order]\" value=\"3\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_8][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_8][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_8][number]\" value=\"8\" type=\"hidden\">				</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_callout 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_callout\" 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-bell\"></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\">Callout Box</div><div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-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\">Callout Box</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_14][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_14][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </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\"><select 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 class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title for Callout box
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_14_mtheme_title\" class=\"input-text-full\" value=\"Visual and creative publications\" name=\"aq_blocks[aq_block_14][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_content\">Text for Callout</label>
							<span class=\"forminputdescription\">
								Text for Callout
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_14_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_14_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_14][mtheme_content]\" id=\"aq_block_14_mtheme_content\">Integer sed tincidunt dui. Cras tincidunt at risus vitae ultrices. Sed at placerat diam. Nam ornare feugiat blandit. Suspendisse potenti.</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-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_button_icon\">Select icon</label>
							<span class=\"forminputdescription\">
								Select 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 id=\"aq_block_14_mtheme_button_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_14][mtheme_button_icon]\" value=\"\" type=\"hidden\"><i class=\"fontawesome_icon preview \"></i></div></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_button_color\">Button color</label>
							<span class=\"forminputdescription\">
								Button color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a tabindex=\"0\" class=\"wp-color-result\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_14_mtheme_button_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_button_color]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><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 id=\"aq_block_14_mtheme_button_text\" class=\"input-text-full\" value=\"Contact\" name=\"aq_blocks[aq_block_14][mtheme_button_text]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_button_link\">Button Link</label>
							<span class=\"forminputdescription\">
								Button Link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_14_mtheme_button_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_14][mtheme_button_link]\" type=\"text\"></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_14][id_base]\" value=\"em_callout\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_14][name]\" value=\"Callout Box\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_14][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_14][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_14][parent]\" value=\"4\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_14][number]\" value=\"14\" type=\"hidden\">				</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\" name=\"aq_blocks[aq_block_13][blockID]\" value=\"\" id=\"blockID\" type=\"text\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" name=\"aq_blocks[aq_block_13][blockNote]\" value=\"\" id=\"blockNote\" type=\"text\">
					  </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\"><select 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 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\"><select 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 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\"><input id=\"aq_block_13_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][margin_top]\" type=\"text\"></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\"><input id=\"aq_block_13_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][margin_bottom]\" type=\"text\"></div></div><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\"><input id=\"aq_block_13_padding_top\" class=\"input-text-full\" value=\"56\" name=\"aq_blocks[aq_block_13][padding_top]\" type=\"text\"></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\"><input id=\"aq_block_13_padding_bottom\" class=\"input-text-full\" value=\"56\" name=\"aq_blocks[aq_block_13][padding_bottom]\" type=\"text\"></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\"><input id=\"aq_block_13_padding_sidespx\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][padding_sidespx]\" type=\"text\"></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\"><input id=\"aq_block_13_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][padding_sides]\" type=\"text\"></div></div><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\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(137, 137, 137);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_13_background_color\" class=\"input-color-picker wp-color-picker\" value=\"#898989\" name=\"aq_blocks[aq_block_13][background_color]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: 99.82px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(138, 138, 138), rgb(138, 138, 138), rgb(138, 138, 138), rgb(138, 138, 138), rgb(138, 138, 138), rgb(138, 138, 138), rgb(138, 138, 138), rgb(138, 138, 138), rgb(138, 138, 138), rgb(138, 138, 138), rgb(138, 138, 138), rgb(138, 138, 138), rgb(138, 138, 138));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></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\"><a tabindex=\"0\" class=\"wp-color-result\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_13_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_13][gradient_color]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla 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: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center 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: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></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\"><select 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 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 id=\"aq_block_13_video_mp4\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][video_mp4]\" type=\"text\"></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 id=\"aq_block_13_video_webm\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][video_webm]\" type=\"text\"></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 id=\"aq_block_13_video_ogv\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][video_ogv]\" type=\"text\"></div></div><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 id=\"aq_block_13_background_image_imageid\" name=\"aq_blocks[aq_block_13][background_imageid]\" value=\"11413\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_13_background_image\" class=\"input-full imagefile-uploader\" value=\"https://dummyimage.com/1400x932/2D5B69/fff.jpg\" name=\"aq_blocks[aq_block_13][background_image]\" type=\"text\"><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\">Scroll effect</label>
							<span class=\"forminputdescription\">
								Scroll effect
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_13_background_scroll\" name=\"aq_blocks[aq_block_13][background_scroll]\"><option value=\"static\" selected=\"selected\">Static</option><option value=\"parallax\">Parallax</option></select></div></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_13][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_13][name]\" value=\"Column Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_13][order]\" value=\"4\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_13][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_13][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_13][number]\" value=\"13\" type=\"hidden\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
									