
								<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\">Big image</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_heroimage 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_heroimage\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(225,164,60,0.3) 0%, rgba(225,164,60,1) 100%);
background: -webkit-linear-gradient(left, rgba(225,164,60,0.5) 0%,rgba(225,164,60,1) 100%);
background: linear-gradient(to right, rgba(225,164,60,0.5) 0%,rgba(225,164,60,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#E1A43Ca5\', endColorstr=\'#E1A43Ca5\',GradientType=1 );\"><i class=\"simpleicon-star\"></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\">Hero Image</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\">Hero Image</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 cf\">
			<div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_image\">Add image</label>
							<span class=\"forminputdescription\">
								Upload an image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_2_mtheme_image_imageid\" name=\"aq_blocks[aq_block_2][mtheme_imageid]\" value=\"8\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_2_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://placehold.it/1400x780/F4DDD2/ffffff/\" name=\"aq_blocks[aq_block_2][mtheme_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_2_mtheme_intensity\">Intensity for Text and ui elements</label>
							<span class=\"forminputdescription\">
								Intensity for Text and ui elements
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_2_mtheme_intensity\" name=\"aq_blocks[aq_block_2][mtheme_intensity]\"><option value=\"default\">Default</option><option value=\"bright\">Bright</option><option value=\"dark\" selected=\"selected\">Dark</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_text\">Hero image assist text</label>
							<span class=\"forminputdescription\">
								Text to display. Displays as a title on bottom of hero image
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_text\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_2][mtheme_text]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_link\">Link</label>
							<span class=\"forminputdescription\">
								Link for hero image navigation
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_link\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_2][mtheme_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_icon\">Display icon</label>
							<span class=\"forminputdescription\">
								Display icon
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_2_mtheme_icon\" name=\"aq_blocks[aq_block_2][mtheme_icon]\"><option value=\"true\" selected=\"selected\">Enable</option><option value=\"false\">Disable</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_text_decoration\">Text decoration</label>
							<span class=\"forminputdescription\">
								Text decoration
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_2_mtheme_text_decoration\" name=\"aq_blocks[aq_block_2][mtheme_text_decoration]\"><option value=\"none\" selected=\"selected\">None</option><option value=\"border\">Border</option><option value=\"border-top-bottom\">Border Top Bottom</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_text_location\">Text Location</label>
							<span class=\"forminputdescription\">
								Text Location
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_2_mtheme_text_location\" name=\"aq_blocks[aq_block_2][mtheme_text_location]\"><option value=\"top\">Top</option><option value=\"middle\">Middle</option><option value=\"bottom\" selected=\"selected\">Bottom</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_text_slide\">Text display.</label>
							<span class=\"forminputdescription\">
								Display slideshow of text.
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_2_mtheme_text_slide\" name=\"aq_blocks[aq_block_2][mtheme_text_slide]\"><option value=\"single\" selected=\"selected\">Single text</option><option value=\"slideshow\">Slideshow</option><option value=\"disable\">Disable</option></select></div></div>			
				<ul id=\"aq-sortable-list-aq_block_2\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_2\">
								<li id=\"aq_block_2_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Kinetika Freelancer						</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_2_tabs-1-title\">Title</label>
						</div>
						<div class=\"formview-rightside\"><textarea rows=\"5\" id=\"aq_block_2_tabs-1-title\" class=\"textarea-full\" name=\"aq_blocks[aq_block_2][tabs][1][title]\">Kinetika Freelancer</textarea>Enter P tags for new lines. eg. <code>&lt;p&gt;Line 1&lt;/p&gt;&lt;p&gt;Line 2&lt;/p&gt;</code></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_2_tabs-1-subtitle\">Subtitle</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_2_tabs-1-subtitle\" class=\"input-full\" name=\"aq_blocks[aq_block_2][tabs][1][subtitle]\" value=\"\" type=\"text\"></div><p></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"herotitle\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_2][id_base]\" value=\"em_heroimage\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_2][name]\" value=\"Hero Image\" 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=\"description_text\">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=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" name=\"aq_blocks[aq_block_1][blockNote]\" value=\"Big image\" 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\">Boxed</option><option value=\"fullwidth\" selected=\"selected\">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\" 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_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=\"\" 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=\"\" 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_sides\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding sides in pixels
							</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\">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-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_background_image\">Background 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=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_1_background_image\" class=\"input-full imagefile-uploader\" value=\"\" 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=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</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=\"Column 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\">services</span>
					<div class=\"blocknote-self\"></div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-3\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-4\" class=\"block block-em_sectionheading span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-4\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"4\" data-mblocktype=\"em_sectionheading\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -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-4\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Section Heading</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"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=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_title\">Section Heading text</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_4_mtheme_title\" class=\"input-text-full\" value=\"Services\" 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_subtitle\">Section subtitle (optional)</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_4_mtheme_subtitle\" class=\"input-text-full\" value=\"Events Coverage and Photography\" name=\"aq_blocks[aq_block_4][mtheme_subtitle]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_align\">Align text</label>
							<span class=\"forminputdescription\">
								Align text
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_4_mtheme_align\" name=\"aq_blocks[aq_block_4][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_size\">Heading size</label>
							<span class=\"forminputdescription\">
								Heading size
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_4_mtheme_size\" name=\"aq_blocks[aq_block_4][mtheme_size]\"><option value=\"1\">h1</option><option value=\"2\" selected=\"selected\">h2</option><option value=\"3\">h3</option><option value=\"4\">h4</option><option value=\"5\">h5</option><option value=\"6\">h6</option></select></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_content_richtext\">Content</label>
							<span class=\"forminputdescription\">
								Add content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_4_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_4_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_4][mtheme_content_richtext]\" id=\"aq_block_4_mtheme_content_richtext\">&lt;p&gt;Fusce aliquam tincidunt hendrerit. Nunc tincidunt id velit sit amet vestibulum. In venenatis tempus odio ut dictum. Curabitur ac nisl molestie, facilisis nibh ac, facilisis ligula. Integer congue malesuada eros congue varius. Sed malesuada dolor eget velit euismod pretium. Etiam porttitor finibus pretium. Nam suscipit vel ligula at dharetra.&lt;/p&gt;</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_button\">Button Text</label>
							<span class=\"forminputdescription\">
								Button Text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_4_mtheme_button\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_4][mtheme_button]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_button_link\">Button link</label>
							<span class=\"forminputdescription\">
								Button link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_4_mtheme_button_link\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_4][mtheme_button_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_width\">Width in percent</label>
							<span class=\"forminputdescription\">
								Width in percent
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_4_mtheme_width\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_4][mtheme_width]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_top\">Padding Top in pixels</label>
							<span class=\"forminputdescription\">
								Top Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_4_mtheme_top\" class=\"input-text-full\" value=\"30\" name=\"aq_blocks[aq_block_4][mtheme_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"forminputdescription\">
								Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_4_mtheme_bottom\" class=\"input-text-full\" value=\"30\" name=\"aq_blocks[aq_block_4][mtheme_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"forminputdescription\">
								Margin Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_4_mtheme_marginbottom\" class=\"input-text-full\" value=\"0\" name=\"aq_blocks[aq_block_4][mtheme_marginbottom]\" type=\"text\"></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_4][id_base]\" value=\"em_sectionheading\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_4][name]\" value=\"Section Heading\" 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=\"span12\" 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=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\" selected=\"selected\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></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(225, 115, 113);\" 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=\"#e17371\" 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: 141.05px; top: 73.78px;\"><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, 4, 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(225, 112, 112), rgb(225, 168, 112), rgb(225, 225, 112), rgb(168, 225, 112), rgb(112, 225, 112), rgb(112, 225, 168), rgb(112, 225, 225), rgb(112, 168, 225), rgb(112, 112, 225), rgb(168, 112, 225), rgb(225, 112, 225), rgb(225, 112, 168), rgb(225, 112, 112));\"><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: 99.7222%;\"></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 a Fontawesome icon</label>
							<span class=\"forminputdescription\">
								Pick a fontawesome 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=\"et-icon-heart\" type=\"hidden\"><i class=\"fontawesome_icon preview et-icon-heart\"></i></div></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=\"Weddings\" 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=\"\" 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=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></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(128, 178, 91);\" 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=\"#80b25b\" 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: 78.12px; top: 101.99px;\"><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(111, 255, 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(178, 92, 92), rgb(178, 135, 92), rgb(178, 178, 92), rgb(135, 178, 92), rgb(92, 178, 92), rgb(92, 178, 135), rgb(92, 178, 178), rgb(92, 135, 178), rgb(92, 92, 178), rgb(135, 92, 178), rgb(178, 92, 178), rgb(178, 92, 135), rgb(178, 92, 92));\"><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: 73.8889%;\"></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 a Fontawesome icon</label>
							<span class=\"forminputdescription\">
								Pick a fontawesome 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=\"et-icon-layers\" type=\"hidden\"><i class=\"fontawesome_icon preview et-icon-layers\"></i></div></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=\"Portraits\" 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=\"\" 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=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></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(103, 143, 181);\" 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=\"#678fb5\" 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: 75.95px; top: 95.48px;\"><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, 132, 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, 104, 104), rgb(182, 143, 104), rgb(182, 182, 104), rgb(143, 182, 104), rgb(104, 182, 104), rgb(104, 182, 143), rgb(104, 182, 182), rgb(104, 143, 182), rgb(104, 104, 182), rgb(143, 104, 182), rgb(182, 104, 182), rgb(182, 104, 143), rgb(182, 104, 104));\"><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: 41.9444%;\"></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 a Fontawesome icon</label>
							<span class=\"forminputdescription\">
								Pick a fontawesome 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=\"et-icon-wine\" type=\"hidden\"><i class=\"fontawesome_icon preview et-icon-wine\"></i></div></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=\"Events\" 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=\"\" 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><li id=\"template-block-8\" 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-8\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"8\" 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-8\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">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_8][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_8][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-8\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_8_mtheme_animated\" name=\"aq_blocks[aq_block_8][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\" selected=\"selected\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_iconplace\">Icon Placement</label>
							<span class=\"forminputdescription\">
								Placement of icon
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_8_mtheme_iconplace\" name=\"aq_blocks[aq_block_8][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_8_mtheme_iconborder\">iCon Border</label>
							<span class=\"forminputdescription\">
								Placement of service boxes
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_8_mtheme_iconborder\" name=\"aq_blocks[aq_block_8][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_8_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(214, 94, 162);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_8_mtheme_iconcolor\" class=\"input-color-picker wp-color-picker\" value=\"#d65ea2\" name=\"aq_blocks[aq_block_8][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: 128.03px; top: 86.8px;\"><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, 145));\"></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(213, 93, 93), rgb(213, 153, 93), rgb(213, 213, 93), rgb(153, 213, 93), rgb(93, 213, 93), rgb(93, 213, 153), rgb(93, 213, 213), rgb(93, 153, 213), rgb(93, 93, 213), rgb(153, 93, 213), rgb(213, 93, 213), rgb(213, 93, 153), rgb(213, 93, 93));\"><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: 9.44444%;\"></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_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_8_mtheme_iconbackground\" class=\"input-color-picker wp-color-picker\" value=\"#f9f9f9\" name=\"aq_blocks[aq_block_8][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_8_mtheme_icon\">Choose a Fontawesome icon</label>
							<span class=\"forminputdescription\">
								Pick a fontawesome 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_8_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_8][mtheme_icon]\" value=\"et-icon-map\" type=\"hidden\"><i class=\"fontawesome_icon preview et-icon-map\"></i></div></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_title\">Service Title</label>
							<span class=\"forminputdescription\">
								Title of the service
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_8_mtheme_title\" class=\"input-text-full\" value=\"Outdoor\" name=\"aq_blocks[aq_block_8][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_link\">Link</label>
							<span class=\"forminputdescription\">
								Link to title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_8_mtheme_link\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_8][mtheme_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_linktext\">Text for link</label>
							<span class=\"forminputdescription\">
								Text for link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_8_mtheme_linktext\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_8][mtheme_linktext]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_content\">Service Content</label>
							<span class=\"forminputdescription\">
								Add the service content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_8_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_8_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_8][mtheme_content]\" id=\"aq_block_8_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_8][id_base]\" value=\"em_serviceboxes\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_8][name]\" value=\"Services\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_8][order]\" value=\"5\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_8][size]\" value=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_8][parent]\" value=\"2\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_8][number]\" value=\"8\" 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=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" name=\"aq_blocks[aq_block_3][blockID]\" value=\"services\" id=\"blockID\" type=\"text\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">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\">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_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=\"110\" 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=\"110\" 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_sides\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_3_padding_sides\" class=\"input-text-full\" value=\"\" 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(167, 77, 77);\" 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=\"#a74d4d\" 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: 80.29px; top: 112.84px;\"><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(168, 77, 77), rgb(168, 122, 77), rgb(168, 168, 77), rgb(122, 168, 77), rgb(77, 168, 77), rgb(77, 168, 122), rgb(77, 168, 168), rgb(77, 122, 168), rgb(77, 77, 168), rgb(122, 77, 168), rgb(168, 77, 168), rgb(168, 77, 122), rgb(168, 77, 77));\"><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\">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-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_background_image\">Background 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=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</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-9\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\">
				<ul class=\"block-controls\">
					<li class=\"block-control-actions cf\">
						<a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove Column Container\"><i class=\"fa fa-trash\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#my-column-content-9\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit Column Container\"><i class=\"fa fa-pencil\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\" data-toggle=\"modal\"><i class=\"fa fa-upload\"></i></a>
					</li>
				</ul>
				<dt class=\"block-handle ui-sortable-handle\">
	 				<div class=\"block-icon\" style=\"color:none;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</div><span class=\"user-control-id\">projects</span>
					<div class=\"blocknote-self\"></div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-9\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-10\" class=\"block block-em_fromtocounter 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-10\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"10\" data-mblocktype=\"em_fromtocounter\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(61,153,112,0.3) 0%, rgba(61,153,112,1) 100%);
background: -webkit-linear-gradient(left, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
background: linear-gradient(to right, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#3D9970a5\', endColorstr=\'#3D9970a5\',GradientType=1 );\"><i class=\"simpleicon-reload\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">From-To Counter</div><div class=\"block-size\">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-10\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">From-To Counter</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input 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 mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_10_mtheme_title\" class=\"input-text-full\" value=\"Parties\" name=\"aq_blocks[aq_block_10][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_description\">Description</label>
							<span class=\"forminputdescription\">
								Description
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_10_mtheme_description\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_10][mtheme_description]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_to\">Count to</label>
							<span class=\"forminputdescription\">
								Count to
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_10_mtheme_to\" class=\"input-text-full\" value=\"205\" name=\"aq_blocks[aq_block_10][mtheme_to]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_icon\">Select Icon</label>
							<span class=\"forminputdescription\">
								Click an icon to select, click again to deselect
							</span>
						</div><div class=\"formview-rightside fontawesome-iconpicker\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_10_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_10][mtheme_icon]\" value=\"fontello-icon-camera\" type=\"hidden\"><i class=\"fontawesome_icon preview fontello-icon-camera\"></i></div></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_iconcolor\">Icon Color</label>
							<span class=\"forminputdescription\">
								Leave blank for default
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(214, 159, 33);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_10_mtheme_iconcolor\" class=\"input-color-picker wp-color-picker\" value=\"#d69f21\" name=\"aq_blocks[aq_block_10][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: 158.41px; top: 112.84px;\"><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, 179, 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(212, 33, 33), rgb(212, 122, 33), rgb(212, 212, 33), rgb(122, 212, 33), rgb(33, 212, 33), rgb(33, 212, 122), rgb(33, 212, 212), rgb(33, 122, 212), rgb(33, 33, 212), rgb(122, 33, 212), rgb(212, 33, 212), rgb(212, 33, 122), rgb(212, 33, 33));\"><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: 88.3333%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_10][id_base]\" value=\"em_fromtocounter\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_10][name]\" value=\"From-To Counter\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_10][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_10][size]\" value=\"span3\" 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_fromtocounter 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-11\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"11\" data-mblocktype=\"em_fromtocounter\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(61,153,112,0.3) 0%, rgba(61,153,112,1) 100%);
background: -webkit-linear-gradient(left, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
background: linear-gradient(to right, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#3D9970a5\', endColorstr=\'#3D9970a5\',GradientType=1 );\"><i class=\"simpleicon-reload\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">From-To Counter</div><div class=\"block-size\">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-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\">From-To Counter</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 mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_11_mtheme_title\" class=\"input-text-full\" value=\"Events\" name=\"aq_blocks[aq_block_11][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_description\">Description</label>
							<span class=\"forminputdescription\">
								Description
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_11_mtheme_description\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_11][mtheme_description]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_to\">Count to</label>
							<span class=\"forminputdescription\">
								Count to
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_11_mtheme_to\" class=\"input-text-full\" value=\"174\" name=\"aq_blocks[aq_block_11][mtheme_to]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_icon\">Select Icon</label>
							<span class=\"forminputdescription\">
								Click an icon to select, click again to deselect
							</span>
						</div><div class=\"formview-rightside fontawesome-iconpicker\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_11_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_11][mtheme_icon]\" value=\"fontello-icon-diamond\" type=\"hidden\"><i class=\"fontawesome_icon preview fontello-icon-diamond\"></i></div></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_iconcolor\">Icon Color</label>
							<span class=\"forminputdescription\">
								Leave blank for default
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(255, 82, 168);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_11_mtheme_iconcolor\" class=\"input-color-picker wp-color-picker\" value=\"#ff52a8\" name=\"aq_blocks[aq_block_11][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: 217px; top: 73.78px;\"><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, 127));\"></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, 82, 82), rgb(255, 168, 82), rgb(255, 255, 82), rgb(168, 255, 82), rgb(82, 255, 82), rgb(82, 255, 168), rgb(82, 255, 255), rgb(82, 168, 255), rgb(82, 82, 255), rgb(168, 82, 255), rgb(255, 82, 255), rgb(255, 82, 168), rgb(255, 82, 82));\"><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: 8.33333%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_11][id_base]\" value=\"em_fromtocounter\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_11][name]\" value=\"From-To Counter\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_11][order]\" value=\"2\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_11][size]\" value=\"span3\" 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_fromtocounter 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-12\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"12\" data-mblocktype=\"em_fromtocounter\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(61,153,112,0.3) 0%, rgba(61,153,112,1) 100%);
background: -webkit-linear-gradient(left, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
background: linear-gradient(to right, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#3D9970a5\', endColorstr=\'#3D9970a5\',GradientType=1 );\"><i class=\"simpleicon-reload\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">From-To Counter</div><div class=\"block-size\">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-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\">From-To Counter</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 mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_12_mtheme_title\" class=\"input-text-full\" value=\"Ceremonies\" name=\"aq_blocks[aq_block_12][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_description\">Description</label>
							<span class=\"forminputdescription\">
								Description
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_12_mtheme_description\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_12][mtheme_description]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_to\">Count to</label>
							<span class=\"forminputdescription\">
								Count to
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_12_mtheme_to\" class=\"input-text-full\" value=\"148\" name=\"aq_blocks[aq_block_12][mtheme_to]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_icon\">Select Icon</label>
							<span class=\"forminputdescription\">
								Click an icon to select, click again to deselect
							</span>
						</div><div class=\"formview-rightside fontawesome-iconpicker\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_12_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_12][mtheme_icon]\" value=\"fontello-icon-heart\" type=\"hidden\"><i class=\"fontawesome_icon preview fontello-icon-heart\"></i></div></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_iconcolor\">Icon Color</label>
							<span class=\"forminputdescription\">
								Leave blank for default
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(161, 213, 70);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_12_mtheme_iconcolor\" class=\"input-color-picker wp-color-picker\" value=\"#a1d546\" name=\"aq_blocks[aq_block_12][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: 136.71px; top: 97.65px;\"><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(162, 255, 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(213, 68, 68), rgb(213, 140, 68), rgb(213, 213, 68), rgb(140, 213, 68), rgb(68, 213, 68), rgb(68, 213, 140), rgb(68, 213, 213), rgb(68, 140, 213), rgb(68, 68, 213), rgb(140, 68, 213), rgb(213, 68, 213), rgb(213, 68, 140), rgb(213, 68, 68));\"><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: 77.2222%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_12][id_base]\" value=\"em_fromtocounter\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_12][name]\" value=\"From-To Counter\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_12][order]\" value=\"3\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_12][size]\" value=\"span3\" 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><li id=\"template-block-13\" class=\"block block-em_fromtocounter 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-13\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"13\" data-mblocktype=\"em_fromtocounter\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(61,153,112,0.3) 0%, rgba(61,153,112,1) 100%);
background: -webkit-linear-gradient(left, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
background: linear-gradient(to right, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#3D9970a5\', endColorstr=\'#3D9970a5\',GradientType=1 );\"><i class=\"simpleicon-reload\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">From-To Counter</div><div class=\"block-size\">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-13\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">From-To Counter</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_13][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_13][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-13\">
						<div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_13_mtheme_title\" class=\"input-text-full\" value=\"Locations\" name=\"aq_blocks[aq_block_13][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_mtheme_description\">Description</label>
							<span class=\"forminputdescription\">
								Description
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_13_mtheme_description\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][mtheme_description]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_mtheme_to\">Count to</label>
							<span class=\"forminputdescription\">
								Count to
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_13_mtheme_to\" class=\"input-text-full\" value=\"218\" name=\"aq_blocks[aq_block_13][mtheme_to]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_mtheme_icon\">Select Icon</label>
							<span class=\"forminputdescription\">
								Click an icon to select, click again to deselect
							</span>
						</div><div class=\"formview-rightside fontawesome-iconpicker\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_13_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_13][mtheme_icon]\" value=\"fontello-icon-location\" type=\"hidden\"><i class=\"fontawesome_icon preview fontello-icon-location\"></i></div></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_mtheme_iconcolor\">Icon Color</label>
							<span class=\"forminputdescription\">
								Leave blank for default
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a tabindex=\"0\" class=\"wp-color-result\" style=\"background-color: rgb(36, 190, 232);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_13_mtheme_iconcolor\" class=\"input-color-picker wp-color-picker\" value=\"#24bee8\" name=\"aq_blocks[aq_block_13][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: 175.77px; top: 101.99px;\"><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, 200, 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(232, 38, 38), rgb(232, 135, 38), rgb(232, 232, 38), rgb(135, 232, 38), rgb(38, 232, 38), rgb(38, 232, 135), rgb(38, 232, 232), rgb(38, 135, 232), rgb(38, 38, 232), rgb(135, 38, 232), rgb(232, 38, 232), rgb(232, 38, 135), rgb(232, 38, 38));\"><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: 46.3889%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_13][id_base]\" value=\"em_fromtocounter\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_13][name]\" value=\"From-To Counter\" 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=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_13][parent]\" value=\"3\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_13][number]\" value=\"13\" 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-9\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" name=\"aq_blocks[aq_block_9][blockID]\" value=\"projects\" id=\"blockID\" type=\"text\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" name=\"aq_blocks[aq_block_9][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_9_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_9_container_type\" name=\"aq_blocks[aq_block_9][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_9_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_9_text_intensity\" name=\"aq_blocks[aq_block_9][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_9_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_9_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_9][margin_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_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_9_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_9][margin_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_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_9_padding_top\" class=\"input-text-full\" value=\"110\" name=\"aq_blocks[aq_block_9][padding_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_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_9_padding_bottom\" class=\"input-text-full\" value=\"70\" name=\"aq_blocks[aq_block_9][padding_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_padding_sides\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_9_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_9][padding_sides]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_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(239, 239, 239);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_9_background_color\" class=\"input-color-picker wp-color-picker\" value=\"#efefef\" name=\"aq_blocks[aq_block_9][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: 13.02px;\"><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(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240), rgb(240, 240, 240));\"><div class=\"iris-slider-offset ui-slider ui-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_9_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_9_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_9][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_9_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_9_gradient_angle\" name=\"aq_blocks[aq_block_9][gradient_angle]\"><option value=\"none\">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-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_background_image\">Background Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_9_background_image_imageid\" name=\"aq_blocks[aq_block_9][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_9_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_9][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_9_background_scroll\">Scroll effect</label>
							<span class=\"forminputdescription\">
								Scroll effect
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_9_background_scroll\" name=\"aq_blocks[aq_block_9][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</option></select></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_9][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_9][name]\" value=\"Fullwidth Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_9][order]\" value=\"3\" 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=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_9][number]\" value=\"9\" type=\"hidden\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
		<li id=\"template-block-14\" 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-14\" 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\">works</span>
					<div class=\"blocknote-self\"></div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-14\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-15\" 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-15\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"15\" 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-15\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">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_15][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_15][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-15\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_15_mtheme_animated\" name=\"aq_blocks[aq_block_15][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_title\">Section Heading text</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_15_mtheme_title\" class=\"input-text-full\" value=\"Works\" name=\"aq_blocks[aq_block_15][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_subtitle\">Section subtitle (optional)</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_15_mtheme_subtitle\" class=\"input-text-full\" value=\"Selected projects from portfolio\" name=\"aq_blocks[aq_block_15][mtheme_subtitle]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_align\">Align text</label>
							<span class=\"forminputdescription\">
								Align text
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_15_mtheme_align\" name=\"aq_blocks[aq_block_15][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</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_15_mtheme_size\">Heading size</label>
							<span class=\"forminputdescription\">
								Heading size
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_15_mtheme_size\" name=\"aq_blocks[aq_block_15][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-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_content_richtext\">Content</label>
							<span class=\"forminputdescription\">
								Add content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_15_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_15_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_15][mtheme_content_richtext]\" id=\"aq_block_15_mtheme_content_richtext\">&lt;p&gt;Fusce aliquam tincidunt hendrerit. Nunc tincidunt id velit sit amet vestibulum. In venenatis tempus odio ut dictum. Curabitur ac nisl molestie, facilisis nibh ac, facilisis ligula. Integer congue malesuada eros congue varius. Sed malesuada dolor eget velit euismod pretium. Etiam porttitor finibus pretium. Nam suscipit vel ligula at dharetra.&lt;/p&gt;</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_button\">Button Text</label>
							<span class=\"forminputdescription\">
								Button Text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_15_mtheme_button\" class=\"input-text-full\" value=\"View More Works\" name=\"aq_blocks[aq_block_15][mtheme_button]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_button_link\">Button link</label>
							<span class=\"forminputdescription\">
								Button link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_15_mtheme_button_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_15][mtheme_button_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_width\">Width in percent</label>
							<span class=\"forminputdescription\">
								Width in percent
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_15_mtheme_width\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_15][mtheme_width]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_top\">Padding Top in pixels</label>
							<span class=\"forminputdescription\">
								Top Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_15_mtheme_top\" class=\"input-text-full\" value=\"100\" name=\"aq_blocks[aq_block_15][mtheme_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"forminputdescription\">
								Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_15_mtheme_bottom\" class=\"input-text-full\" value=\"30\" name=\"aq_blocks[aq_block_15][mtheme_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"forminputdescription\">
								Margin Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_15_mtheme_marginbottom\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_15][mtheme_marginbottom]\" type=\"text\"></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_15][id_base]\" value=\"em_sectionheading\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_15][name]\" value=\"Section Heading\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_15][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_15][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_15][parent]\" value=\"4\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_15][number]\" value=\"15\" 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-16\" class=\"block block-em_metro 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-16\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"16\" data-mblocktype=\"em_metro\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(225,164,60,0.3) 0%, rgba(225,164,60,1) 100%);
background: -webkit-linear-gradient(left, rgba(225,164,60,0.5) 0%,rgba(225,164,60,1) 100%);
background: linear-gradient(to right, rgba(225,164,60,0.5) 0%,rgba(225,164,60,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#E1A43Ca5\', endColorstr=\'#E1A43Ca5\',GradientType=1 );\"><i class=\"simpleicon-grid\"></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\">Metro Grid</div><div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-16\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Metro Grid</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_16][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_16][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-16\">
						<div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_animated\">On scroll animated</label>
							<span class=\"forminputdescription\">
								Display animated images while scrolling
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_16_mtheme_animated\" name=\"aq_blocks[aq_block_16][mtheme_animated]\"><option value=\"false\">No</option><option value=\"true\" selected=\"selected\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-images\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_pb_image_ids\">Add images</label>
							<span class=\"forminputdescription\">
								Add images
							</span>
						</div><div class=\"formview-rightside images\"><input class=\"mtheme-gallery-selector-ids\" value=\"7808,7795,7793,7796,7799,7047,7802,7806,7807\" name=\"aq_blocks[aq_block_16][mtheme_pb_image_ids]\" type=\"hidden\"><button type=\"button\" class=\"mtheme-gallery-selector\">Select Images</button><div class=\"description\"><ul class=\"mtheme-gallery-selector-list\"><li><img src=\"\" alt=\"\" width=\"\" height=\"\"></li><li><img src=\"\" alt=\"\" width=\"\" height=\"\"></li><li><img src=\"\" alt=\"\" width=\"\" height=\"\"></li><li><img src=\"\" alt=\"\" width=\"\" height=\"\"></li><li><img src=\"\" alt=\"\" width=\"\" height=\"\"></li><li><img src=\"\" alt=\"\" width=\"\" height=\"\"></li><li><img src=\"\" alt=\"\" width=\"\" height=\"\"></li><li><img src=\"\" alt=\"\" width=\"\" height=\"\"></li><li><img src=\"\" alt=\"\" width=\"\" height=\"\"></li></ul></div></div></div>		
		<input class=\"id_base\" name=\"aq_blocks[aq_block_16][id_base]\" value=\"em_metro\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_16][name]\" value=\"Metro Grid\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_16][order]\" value=\"2\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_16][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_16][parent]\" value=\"4\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_16][number]\" value=\"16\" 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-14\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" name=\"aq_blocks[aq_block_14][blockID]\" value=\"works\" id=\"blockID\" type=\"text\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" name=\"aq_blocks[aq_block_14][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_14_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_14_container_type\" name=\"aq_blocks[aq_block_14][container_type]\"><option value=\"boxed\">Boxed</option><option value=\"fullwidth\" selected=\"selected\">Fullwidth</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_14_text_intensity\" name=\"aq_blocks[aq_block_14][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_14_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_14_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_14][margin_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_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_14_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_14][margin_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_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_14_padding_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_14][padding_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_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_14_padding_bottom\" class=\"input-text-full\" value=\"80\" name=\"aq_blocks[aq_block_14][padding_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_padding_sides\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_14_padding_sides\" class=\"input-text-full\" value=\"80\" name=\"aq_blocks[aq_block_14][padding_sides]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_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(102, 102, 102);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_14_background_color\" class=\"input-color-picker wp-color-picker\" value=\"#666666\" name=\"aq_blocks[aq_block_14][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: 130.2px;\"><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(102, 102, 102), rgb(102, 102, 102), rgb(102, 102, 102), rgb(102, 102, 102), rgb(102, 102, 102), rgb(102, 102, 102), rgb(102, 102, 102), rgb(102, 102, 102), rgb(102, 102, 102), rgb(102, 102, 102), rgb(102, 102, 102), rgb(102, 102, 102), rgb(102, 102, 102));\"><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_14_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_14_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_14][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_14_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_14_gradient_angle\" name=\"aq_blocks[aq_block_14][gradient_angle]\"><option value=\"none\">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-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_background_image\">Background Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_14_background_image_imageid\" name=\"aq_blocks[aq_block_14][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_14_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_14][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_14_background_scroll\">Scroll effect</label>
							<span class=\"forminputdescription\">
								Scroll effect
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_14_background_scroll\" name=\"aq_blocks[aq_block_14][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</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_14][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_14][name]\" value=\"Fullwidth Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_14][order]\" value=\"4\" 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=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_14][number]\" value=\"14\" type=\"hidden\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
		<li id=\"template-block-17\" 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-17\" 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\">Another big image</div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-17\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-18\" class=\"block block-em_heroimage 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-18\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"18\" data-mblocktype=\"em_heroimage\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(225,164,60,0.3) 0%, rgba(225,164,60,1) 100%);
background: -webkit-linear-gradient(left, rgba(225,164,60,0.5) 0%,rgba(225,164,60,1) 100%);
background: linear-gradient(to right, rgba(225,164,60,0.5) 0%,rgba(225,164,60,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#E1A43Ca5\', endColorstr=\'#E1A43Ca5\',GradientType=1 );\"><i class=\"simpleicon-star\"></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\">Hero Image</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-18\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Hero Image</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_18][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_18][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-18\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_image\">Add image</label>
							<span class=\"forminputdescription\">
								Upload an image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_18_mtheme_image_imageid\" name=\"aq_blocks[aq_block_18][mtheme_imageid]\" value=\"9\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_18_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://placehold.it/1400x780/B65453/ffffff/\" name=\"aq_blocks[aq_block_18][mtheme_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_18_mtheme_intensity\">Intensity for Text and ui elements</label>
							<span class=\"forminputdescription\">
								Intensity for Text and ui elements
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_18_mtheme_intensity\" name=\"aq_blocks[aq_block_18][mtheme_intensity]\"><option value=\"default\">Default</option><option value=\"bright\" selected=\"selected\">Bright</option><option value=\"dark\">Dark</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_text\">Hero image assist text</label>
							<span class=\"forminputdescription\">
								Text to display. Displays as a title on bottom of hero image
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_18_mtheme_text\" class=\"input-text-full\" value=\"Works\" name=\"aq_blocks[aq_block_18][mtheme_text]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_link\">Link</label>
							<span class=\"forminputdescription\">
								Link for hero image navigation
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_18_mtheme_link\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_18][mtheme_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_icon\">Display icon</label>
							<span class=\"forminputdescription\">
								Display icon
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_18_mtheme_icon\" name=\"aq_blocks[aq_block_18][mtheme_icon]\"><option value=\"true\">Enable</option><option value=\"false\" selected=\"selected\">Disable</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_text_decoration\">Text decoration</label>
							<span class=\"forminputdescription\">
								Text decoration
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_18_mtheme_text_decoration\" name=\"aq_blocks[aq_block_18][mtheme_text_decoration]\"><option value=\"none\" selected=\"selected\">None</option><option value=\"border\">Border</option><option value=\"border-top-bottom\">Border Top Bottom</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_text_location\">Text Location</label>
							<span class=\"forminputdescription\">
								Text Location
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_18_mtheme_text_location\" name=\"aq_blocks[aq_block_18][mtheme_text_location]\"><option value=\"top\">Top</option><option value=\"middle\">Middle</option><option value=\"bottom\" selected=\"selected\">Bottom</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_text_slide\">Text display.</label>
							<span class=\"forminputdescription\">
								Display slideshow of text.
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_18_mtheme_text_slide\" name=\"aq_blocks[aq_block_18][mtheme_text_slide]\"><option value=\"single\">Single text</option><option value=\"slideshow\">Slideshow</option><option value=\"disable\" selected=\"selected\">Disable</option></select></div></div>			
				<ul id=\"aq-sortable-list-aq_block_18\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_18\">
								<li id=\"aq_block_18_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Kinetika Fullscreen						</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_18_tabs-1-title\">Title</label>
						</div>
						<div class=\"formview-rightside\"><textarea rows=\"5\" id=\"aq_block_18_tabs-1-title\" class=\"textarea-full\" name=\"aq_blocks[aq_block_18][tabs][1][title]\">Kinetika Fullscreen</textarea>Enter P tags for new lines. eg. <code>&lt;p&gt;Line 1&lt;/p&gt;&lt;p&gt;Line 2&lt;/p&gt;</code></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_18_tabs-1-subtitle\">Subtitle</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_18_tabs-1-subtitle\" class=\"input-full\" name=\"aq_blocks[aq_block_18][tabs][1][subtitle]\" value=\"Photographer / Graphics Designer / Videographer\" type=\"text\"></div><p></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"herotitle\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_18][id_base]\" value=\"em_heroimage\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_18][name]\" value=\"Hero Image\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_18][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_18][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_18][parent]\" value=\"5\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_18][number]\" value=\"18\" 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-17\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" name=\"aq_blocks[aq_block_17][blockID]\" value=\"\" id=\"blockID\" type=\"text\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" name=\"aq_blocks[aq_block_17][blockNote]\" value=\"Another big image\" 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_17_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_17_container_type\" name=\"aq_blocks[aq_block_17][container_type]\"><option value=\"boxed\">Boxed</option><option value=\"fullwidth\" selected=\"selected\">Fullwidth</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_17_text_intensity\" name=\"aq_blocks[aq_block_17][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_17_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_17_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_17][margin_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_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_17_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_17][margin_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_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_17_padding_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_17][padding_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_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_17_padding_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_17][padding_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_padding_sides\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_17_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_17][padding_sides]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_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_17_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_17][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_17_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_17_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_17][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_17_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_17_gradient_angle\" name=\"aq_blocks[aq_block_17][gradient_angle]\"><option value=\"none\">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-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_background_image\">Background Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_17_background_image_imageid\" name=\"aq_blocks[aq_block_17][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_17_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_17][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_17_background_scroll\">Scroll effect</label>
							<span class=\"forminputdescription\">
								Scroll effect
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_17_background_scroll\" name=\"aq_blocks[aq_block_17][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</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_17][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_17][name]\" value=\"Column Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_17][order]\" value=\"5\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_17][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_17][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_17][number]\" value=\"17\" type=\"hidden\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
		<li id=\"template-block-19\" 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-19\" 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\">packages</span>
					<div class=\"blocknote-self\"></div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-19\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-20\" 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-20\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"20\" 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-20\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">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_20][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_20][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-20\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_20_mtheme_animated\" name=\"aq_blocks[aq_block_20][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_title\">Section Heading text</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_20_mtheme_title\" class=\"input-text-full\" value=\"Packages\" name=\"aq_blocks[aq_block_20][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_subtitle\">Section subtitle (optional)</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_20_mtheme_subtitle\" class=\"input-text-full\" value=\"Choose among the best\" name=\"aq_blocks[aq_block_20][mtheme_subtitle]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_align\">Align text</label>
							<span class=\"forminputdescription\">
								Align text
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_20_mtheme_align\" name=\"aq_blocks[aq_block_20][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</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_20_mtheme_size\">Heading size</label>
							<span class=\"forminputdescription\">
								Heading size
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_20_mtheme_size\" name=\"aq_blocks[aq_block_20][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-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_content_richtext\">Content</label>
							<span class=\"forminputdescription\">
								Add content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_20_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_20_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_20][mtheme_content_richtext]\" id=\"aq_block_20_mtheme_content_richtext\">&lt;p&gt;Fusce aliquam tincidunt hendrerit. Nunc tincidunt id velit sit amet vestibulum. In venenatis tempus odio ut dictum. Curabitur ac nisl molestie, facilisis nibh ac, facilisis ligula. Integer congue malesuada eros congue varius. Sed malesuada dolor eget velit euismod pretium. Etiam porttitor finibus pretium. Nam suscipit vel ligula at dharetra.&lt;/p&gt;</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_button\">Button Text</label>
							<span class=\"forminputdescription\">
								Button Text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_20_mtheme_button\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_20][mtheme_button]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_button_link\">Button link</label>
							<span class=\"forminputdescription\">
								Button link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_20_mtheme_button_link\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_20][mtheme_button_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_width\">Width in percent</label>
							<span class=\"forminputdescription\">
								Width in percent
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_20_mtheme_width\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_20][mtheme_width]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_top\">Padding Top in pixels</label>
							<span class=\"forminputdescription\">
								Top Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_20_mtheme_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_20][mtheme_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"forminputdescription\">
								Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_20_mtheme_bottom\" class=\"input-text-full\" value=\"30\" name=\"aq_blocks[aq_block_20][mtheme_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"forminputdescription\">
								Margin Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_20_mtheme_marginbottom\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_20][mtheme_marginbottom]\" type=\"text\"></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_20][id_base]\" value=\"em_sectionheading\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_20][name]\" value=\"Section Heading\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_20][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_20][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_20][parent]\" value=\"6\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_20][number]\" value=\"20\" 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-21\" class=\"block block-em_pricingservice span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-21\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"21\" data-mblocktype=\"em_pricingservice\" 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,133,27,0.3) 0%, rgba(255,133,27,1) 100%);
background: -webkit-linear-gradient(left, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
background: linear-gradient(to right, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#FF851Ba5\', endColorstr=\'#FF851Ba5\',GradientType=1 );\"><i class=\"simpleicon-calculator\"></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 Service</div><div class=\"block-size\">3/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-21\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Pricing Service</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_21][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_21][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-21\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_21_mtheme_animated\" name=\"aq_blocks[aq_block_21][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\" selected=\"selected\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_title\">Column Title</label>
							<span class=\"forminputdescription\">
								Column title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_21_mtheme_title\" class=\"input-text-full\" value=\"Small Ceremony\" name=\"aq_blocks[aq_block_21][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_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(219, 199, 67);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_21_mtheme_title_bgcolor\" class=\"input-color-picker wp-color-picker\" value=\"#dbc743\" name=\"aq_blocks[aq_block_21][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: 147.56px; top: 95.48px;\"><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, 221, 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(219, 67, 67), rgb(219, 143, 67), rgb(219, 219, 67), rgb(143, 219, 67), rgb(67, 219, 67), rgb(67, 219, 143), rgb(67, 219, 219), rgb(67, 143, 219), rgb(67, 67, 219), rgb(143, 67, 219), rgb(219, 67, 219), rgb(219, 67, 143), rgb(219, 67, 67));\"><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: 85.5556%;\"></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_21_mtheme_featured\">Make Featured</label>
							<span class=\"forminputdescription\">
								Make Featured
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_21_mtheme_featured\" name=\"aq_blocks[aq_block_21][mtheme_featured]\"><option value=\"true\">Yes</option><option value=\"false\" selected=\"selected\">No</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_currency\">Currency Symbol</label>
							<span class=\"forminputdescription\">
								Enter currency symbol.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_21_mtheme_currency\" class=\"input-text-full\" value=\"$\" name=\"aq_blocks[aq_block_21][mtheme_currency]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_price\">Price value</label>
							<span class=\"forminputdescription\">
								Enter price value.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_21_mtheme_price\" class=\"input-text-full\" value=\"1500\" name=\"aq_blocks[aq_block_21][mtheme_price]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_duration\">Enter duration</label>
							<span class=\"forminputdescription\">
								Enter duration.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_21_mtheme_duration\" class=\"input-text-full\" value=\"4 hours\" name=\"aq_blocks[aq_block_21][mtheme_duration]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_link\">Button link</label>
							<span class=\"forminputdescription\">
								Button link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_21_mtheme_link\" class=\"input-text-full\" value=\"#contactus\" name=\"aq_blocks[aq_block_21][mtheme_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_21_mtheme_button_text\" class=\"input-text-full\" value=\"Contact us\" name=\"aq_blocks[aq_block_21][mtheme_button_text]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_content_richtext\">Rich Text</label>
							<span class=\"forminputdescription\">
								Add the content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_21_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_21_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_21][mtheme_content_richtext]\" id=\"aq_block_21_mtheme_content_richtext\">&lt;p&gt;Up to 4 hours of coverage&lt;/p&gt;
&lt;p&gt;Five 8x10 prints of your choice&lt;/p&gt;
&lt;p&gt;High resolution digital images&lt;/p&gt;
&lt;p&gt;Full rights to prints&lt;/p&gt;
&lt;p&gt;Free retouching!&lt;/p&gt;</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_21][id_base]\" value=\"em_pricingservice\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_21][name]\" value=\"Pricing Service\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_21][order]\" value=\"2\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_21][size]\" value=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_21][parent]\" value=\"6\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_21][number]\" value=\"21\" 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-22\" class=\"block block-em_pricingservice span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-22\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"22\" data-mblocktype=\"em_pricingservice\" 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,133,27,0.3) 0%, rgba(255,133,27,1) 100%);
background: -webkit-linear-gradient(left, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
background: linear-gradient(to right, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#FF851Ba5\', endColorstr=\'#FF851Ba5\',GradientType=1 );\"><i class=\"simpleicon-calculator\"></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 Service</div><div class=\"block-size\">3/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-22\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Pricing Service</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_22][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_22][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-22\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_22_mtheme_animated\" name=\"aq_blocks[aq_block_22][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_title\">Column Title</label>
							<span class=\"forminputdescription\">
								Column title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_22_mtheme_title\" class=\"input-text-full\" value=\"Silver Package\" name=\"aq_blocks[aq_block_22][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_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(183, 183, 183);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_22_mtheme_title_bgcolor\" class=\"input-color-picker wp-color-picker\" value=\"#b7b7b7\" name=\"aq_blocks[aq_block_22][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: 0px; top: 60.76px;\"><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(184, 184, 184), rgb(184, 184, 184), rgb(184, 184, 184), rgb(184, 184, 184), rgb(184, 184, 184), rgb(184, 184, 184), rgb(184, 184, 184), rgb(184, 184, 184), rgb(184, 184, 184), rgb(184, 184, 184), rgb(184, 184, 184), rgb(184, 184, 184), rgb(184, 184, 184));\"><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_22_mtheme_featured\">Make Featured</label>
							<span class=\"forminputdescription\">
								Make Featured
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_22_mtheme_featured\" name=\"aq_blocks[aq_block_22][mtheme_featured]\"><option value=\"true\">Yes</option><option value=\"false\" selected=\"selected\">No</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_currency\">Currency Symbol</label>
							<span class=\"forminputdescription\">
								Enter currency symbol.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_22_mtheme_currency\" class=\"input-text-full\" value=\"$\" name=\"aq_blocks[aq_block_22][mtheme_currency]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_price\">Price value</label>
							<span class=\"forminputdescription\">
								Enter price value.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_22_mtheme_price\" class=\"input-text-full\" value=\"1800\" name=\"aq_blocks[aq_block_22][mtheme_price]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_duration\">Enter duration</label>
							<span class=\"forminputdescription\">
								Enter duration.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_22_mtheme_duration\" class=\"input-text-full\" value=\"6 hours\" name=\"aq_blocks[aq_block_22][mtheme_duration]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_link\">Button link</label>
							<span class=\"forminputdescription\">
								Button link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_22_mtheme_link\" class=\"input-text-full\" value=\"#contactus\" name=\"aq_blocks[aq_block_22][mtheme_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_22_mtheme_button_text\" class=\"input-text-full\" value=\"Contact us\" name=\"aq_blocks[aq_block_22][mtheme_button_text]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_content_richtext\">Rich Text</label>
							<span class=\"forminputdescription\">
								Add the content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_22_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_22_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_22][mtheme_content_richtext]\" id=\"aq_block_22_mtheme_content_richtext\">&lt;p&gt;Up to 6 Hours of coverage&lt;/p&gt;
&lt;p&gt;Photo Album&lt;/p&gt;
&lt;p&gt;Ten 8x10 prints of your choice&lt;/p&gt;
&lt;p&gt;High resolution digital images&lt;/p&gt;
&lt;p&gt;Full rights to prints&lt;/p&gt;
&lt;p&gt;Free retouching!&lt;/p&gt;</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_22][id_base]\" value=\"em_pricingservice\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_22][name]\" value=\"Pricing Service\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_22][order]\" value=\"3\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_22][size]\" value=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_22][parent]\" value=\"6\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_22][number]\" value=\"22\" 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-23\" class=\"block block-em_pricingservice span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-23\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"23\" data-mblocktype=\"em_pricingservice\" 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,133,27,0.3) 0%, rgba(255,133,27,1) 100%);
background: -webkit-linear-gradient(left, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
background: linear-gradient(to right, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#FF851Ba5\', endColorstr=\'#FF851Ba5\',GradientType=1 );\"><i class=\"simpleicon-calculator\"></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 Service</div><div class=\"block-size\">3/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-23\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Pricing Service</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_23][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_23][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-23\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_23_mtheme_animated\" name=\"aq_blocks[aq_block_23][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_title\">Column Title</label>
							<span class=\"forminputdescription\">
								Column title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_23_mtheme_title\" class=\"input-text-full\" value=\"Diamond Package\" name=\"aq_blocks[aq_block_23][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_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(239, 88, 55);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_23_mtheme_title_bgcolor\" class=\"input-color-picker wp-color-picker\" value=\"#ef5837\" name=\"aq_blocks[aq_block_23][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: 184.45px; top: 91.14px;\"><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, 47, 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(239, 57, 57), rgb(239, 148, 57), rgb(239, 239, 57), rgb(148, 239, 57), rgb(57, 239, 57), rgb(57, 239, 148), rgb(57, 239, 239), rgb(57, 148, 239), rgb(57, 57, 239), rgb(148, 57, 239), rgb(239, 57, 239), rgb(239, 57, 148), rgb(239, 57, 57));\"><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: 96.9444%;\"></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_23_mtheme_featured\">Make Featured</label>
							<span class=\"forminputdescription\">
								Make Featured
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_23_mtheme_featured\" name=\"aq_blocks[aq_block_23][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_23_mtheme_currency\">Currency Symbol</label>
							<span class=\"forminputdescription\">
								Enter currency symbol.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_23_mtheme_currency\" class=\"input-text-full\" value=\"$\" name=\"aq_blocks[aq_block_23][mtheme_currency]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_price\">Price value</label>
							<span class=\"forminputdescription\">
								Enter price value.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_23_mtheme_price\" class=\"input-text-full\" value=\"3000\" name=\"aq_blocks[aq_block_23][mtheme_price]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_duration\">Enter duration</label>
							<span class=\"forminputdescription\">
								Enter duration.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_23_mtheme_duration\" class=\"input-text-full\" value=\"10 hours\" name=\"aq_blocks[aq_block_23][mtheme_duration]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_link\">Button link</label>
							<span class=\"forminputdescription\">
								Button link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_23_mtheme_link\" class=\"input-text-full\" value=\"#contactus\" name=\"aq_blocks[aq_block_23][mtheme_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_23_mtheme_button_text\" class=\"input-text-full\" value=\"Contact us\" name=\"aq_blocks[aq_block_23][mtheme_button_text]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_23_mtheme_content_richtext\">Rich Text</label>
							<span class=\"forminputdescription\">
								Add the content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_23_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_23_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_23][mtheme_content_richtext]\" id=\"aq_block_23_mtheme_content_richtext\">&lt;p&gt;Up to 10 Hours of coverage&lt;/p&gt;
&lt;p&gt;Engagement session&lt;/p&gt;
&lt;p&gt;Photo Album&lt;/p&gt;
&lt;p&gt;20 8x10 prints of your choosing&lt;/p&gt;
&lt;p&gt;16x20 gallery wrapped canvas!&lt;/p&gt;
&lt;p&gt;High resolution digital images&lt;/p&gt;
&lt;p&gt;Full rights to prints&lt;/p&gt;
&lt;p&gt;Free retouching!&lt;/p&gt;</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_23][id_base]\" value=\"em_pricingservice\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_23][name]\" value=\"Pricing Service\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_23][order]\" value=\"4\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_23][size]\" value=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_23][parent]\" value=\"6\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_23][number]\" value=\"23\" 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-24\" class=\"block block-em_pricingservice 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-24\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"24\" data-mblocktype=\"em_pricingservice\" 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,133,27,0.3) 0%, rgba(255,133,27,1) 100%);
background: -webkit-linear-gradient(left, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
background: linear-gradient(to right, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#FF851Ba5\', endColorstr=\'#FF851Ba5\',GradientType=1 );\"><i class=\"simpleicon-calculator\"></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 Service</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-24\">						  <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 Service</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_24][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_24][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-24\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_24_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_24_mtheme_animated\" name=\"aq_blocks[aq_block_24][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\" selected=\"selected\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_24_mtheme_title\">Column Title</label>
							<span class=\"forminputdescription\">
								Column title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_24_mtheme_title\" class=\"input-text-full\" value=\"Gold Package\" name=\"aq_blocks[aq_block_24][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_24_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(226, 151, 52);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_24_mtheme_title_bgcolor\" class=\"input-color-picker wp-color-picker\" value=\"#e29734\" name=\"aq_blocks[aq_block_24][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: 162.75px; top: 97.65px;\"><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, 145, 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(226, 54, 54), rgb(226, 140, 54), rgb(226, 226, 54), rgb(140, 226, 54), rgb(54, 226, 54), rgb(54, 226, 140), rgb(54, 226, 226), rgb(54, 140, 226), rgb(54, 54, 226), rgb(140, 54, 226), rgb(226, 54, 226), rgb(226, 54, 140), rgb(226, 54, 54));\"><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: 90.5556%;\"></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_24_mtheme_featured\">Make Featured</label>
							<span class=\"forminputdescription\">
								Make Featured
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_24_mtheme_featured\" name=\"aq_blocks[aq_block_24][mtheme_featured]\"><option value=\"true\">Yes</option><option value=\"false\" selected=\"selected\">No</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_24_mtheme_currency\">Currency Symbol</label>
							<span class=\"forminputdescription\">
								Enter currency symbol.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_24_mtheme_currency\" class=\"input-text-full\" value=\"$\" name=\"aq_blocks[aq_block_24][mtheme_currency]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_24_mtheme_price\">Price value</label>
							<span class=\"forminputdescription\">
								Enter price value.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_24_mtheme_price\" class=\"input-text-full\" value=\"2500\" name=\"aq_blocks[aq_block_24][mtheme_price]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_24_mtheme_duration\">Enter duration</label>
							<span class=\"forminputdescription\">
								Enter duration.
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_24_mtheme_duration\" class=\"input-text-full\" value=\"8 hours\" name=\"aq_blocks[aq_block_24][mtheme_duration]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_24_mtheme_link\">Button link</label>
							<span class=\"forminputdescription\">
								Button link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_24_mtheme_link\" class=\"input-text-full\" value=\"#contactus\" name=\"aq_blocks[aq_block_24][mtheme_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_24_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_24_mtheme_button_text\" class=\"input-text-full\" value=\"Contact us\" name=\"aq_blocks[aq_block_24][mtheme_button_text]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_24_mtheme_content_richtext\">Rich Text</label>
							<span class=\"forminputdescription\">
								Add the content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_24_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_24_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_24][mtheme_content_richtext]\" id=\"aq_block_24_mtheme_content_richtext\">&lt;p&gt;Up to 8 hours of coverage&lt;/p&gt;
&lt;p&gt;Engagement session&lt;/p&gt;
&lt;p&gt;Photo Album&lt;/p&gt;
&lt;p&gt;Ten 8x10 prints of your choosing&lt;/p&gt;
&lt;p&gt;High resolution digital images&lt;/p&gt;
&lt;p&gt;Full rights to prints&lt;/p&gt;
&lt;p&gt;Free retouching!&lt;/p&gt;</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_24][id_base]\" value=\"em_pricingservice\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_24][name]\" value=\"Pricing Service\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_24][order]\" value=\"5\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_24][size]\" value=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_24][parent]\" value=\"6\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_24][number]\" value=\"24\" 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-19\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" name=\"aq_blocks[aq_block_19][blockID]\" value=\"packages\" id=\"blockID\" type=\"text\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" name=\"aq_blocks[aq_block_19][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_19_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_19_container_type\" name=\"aq_blocks[aq_block_19][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_19_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_19_text_intensity\" name=\"aq_blocks[aq_block_19][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_19_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_19_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_19][margin_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_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_19_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_19][margin_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_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_19_padding_top\" class=\"input-text-full\" value=\"120\" name=\"aq_blocks[aq_block_19][padding_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_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_19_padding_bottom\" class=\"input-text-full\" value=\"100\" name=\"aq_blocks[aq_block_19][padding_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_padding_sides\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_19_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_19][padding_sides]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_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(22, 125, 130);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_19_background_color\" class=\"input-color-picker wp-color-picker\" value=\"#167d82\" name=\"aq_blocks[aq_block_19][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: 154.07px; top: 151.9px;\"><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, 242, 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(131, 22, 22), rgb(131, 77, 22), rgb(131, 131, 22), rgb(76, 131, 22), rgb(22, 131, 22), rgb(22, 131, 76), rgb(22, 131, 131), rgb(22, 77, 131), rgb(22, 22, 131), rgb(77, 22, 131), rgb(131, 22, 131), rgb(131, 22, 76), rgb(131, 22, 22));\"><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: 49.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-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_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_19_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_19][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_19_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_19_gradient_angle\" name=\"aq_blocks[aq_block_19][gradient_angle]\"><option value=\"none\">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-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_background_image\">Background Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_19_background_image_imageid\" name=\"aq_blocks[aq_block_19][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_19_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_19][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_19_background_scroll\">Scroll effect</label>
							<span class=\"forminputdescription\">
								Scroll effect
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_19_background_scroll\" name=\"aq_blocks[aq_block_19][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</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_19][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_19][name]\" value=\"Column Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_19][order]\" value=\"6\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_19][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_19][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_19][number]\" value=\"19\" type=\"hidden\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
		<li id=\"template-block-25\" 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-25\" 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\">customers</span>
					<div class=\"blocknote-self\"></div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-25\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-26\" 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-26\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"26\" 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-26\">						  <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_26][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_26][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-26\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_26_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_26_mtheme_animated\" name=\"aq_blocks[aq_block_26][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_26_mtheme_title\">Section Heading text</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_26_mtheme_title\" class=\"input-text-full\" value=\"What they say\" name=\"aq_blocks[aq_block_26][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_26_mtheme_subtitle\">Section subtitle (optional)</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_26_mtheme_subtitle\" class=\"input-text-full\" value=\"Some of our customers\" name=\"aq_blocks[aq_block_26][mtheme_subtitle]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_26_mtheme_align\">Align text</label>
							<span class=\"forminputdescription\">
								Align text
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_26_mtheme_align\" name=\"aq_blocks[aq_block_26][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</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_26_mtheme_size\">Heading size</label>
							<span class=\"forminputdescription\">
								Heading size
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_26_mtheme_size\" name=\"aq_blocks[aq_block_26][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-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_26_mtheme_content_richtext\">Content</label>
							<span class=\"forminputdescription\">
								Add content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_26_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_26_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_26][mtheme_content_richtext]\" id=\"aq_block_26_mtheme_content_richtext\">&lt;p&gt;Fusce aliquam tincidunt hendrerit. Nunc tincidunt id velit sit amet vestibulum. In venenatis tempus odio ut dictum. Curabitur ac nisl molestie, facilisis nibh ac, facilisis ligula. Integer congue malesuada eros congue varius. Sed malesuada dolor eget velit euismod pretium. Etiam porttitor finibus pretium. Nam suscipit vel ligula at dharetra.&lt;/p&gt;</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_26_mtheme_button\">Button Text</label>
							<span class=\"forminputdescription\">
								Button Text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_26_mtheme_button\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_26][mtheme_button]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_26_mtheme_button_link\">Button link</label>
							<span class=\"forminputdescription\">
								Button link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_26_mtheme_button_link\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_26][mtheme_button_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_26_mtheme_width\">Width in percent</label>
							<span class=\"forminputdescription\">
								Width in percent
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_26_mtheme_width\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_26][mtheme_width]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_26_mtheme_top\">Padding Top in pixels</label>
							<span class=\"forminputdescription\">
								Top Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_26_mtheme_top\" class=\"input-text-full\" value=\"50\" name=\"aq_blocks[aq_block_26][mtheme_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_26_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"forminputdescription\">
								Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_26_mtheme_bottom\" class=\"input-text-full\" value=\"10\" name=\"aq_blocks[aq_block_26][mtheme_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_26_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"forminputdescription\">
								Margin Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_26_mtheme_marginbottom\" class=\"input-text-full\" value=\"30\" name=\"aq_blocks[aq_block_26][mtheme_marginbottom]\" type=\"text\"></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_26][id_base]\" value=\"em_sectionheading\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_26][name]\" value=\"Section Heading\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_26][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_26][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_26][parent]\" value=\"7\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_26][number]\" value=\"26\" 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-27\" class=\"block block-em_testimonials 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-27\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"27\" data-mblocktype=\"em_testimonials\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(61,153,112,0.3) 0%, rgba(61,153,112,1) 100%);
background: -webkit-linear-gradient(left, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
background: linear-gradient(to right, rgba(61,153,112,0.5) 0%,rgba(61,153,112,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#3D9970a5\', endColorstr=\'#3D9970a5\',GradientType=1 );\"><i class=\"simpleicon-speech\"></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\">Testimonials</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-27\">						  <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\">Testimonials</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_27][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_27][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-27\">
									<div class=\"description cf\">
						
				<ul id=\"aq-sortable-list-aq_block_27\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_27\">
								<li id=\"aq_block_27_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Oscar Wilde						</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_27_tabs-1-name\">Client Name</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_27_tabs-1-name\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][1][name]\" value=\"Oscar Wilde\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_27_tabs-1-company\">Company</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_27_tabs-1-company\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][1][company]\" value=\"\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_27_tabs-1-link\">Company link</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_27_tabs-1-link\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][1][link]\" value=\"\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_27_tabs-1-image\">Image</label>
						</div>
						<div class=\"formview-rightside\"><img class=\"screenshot\" src=\"\" alt=\"\"><input id=\"aq_block_27_tabs-1-imageid\" name=\"aq_blocks[aq_block_27][tabs][1][imageid]\" value=\"\" type=\"hidden\"><input id=\"aq_block_27_tabs-1-image\" readonly=\"\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_27][tabs][1][image]\" type=\"text\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a href=\"#\" class=\"remove_image button\" rel=\"image\">Remove</a></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_27_tabs-1-quote\">Quote</label>
						</div>
						<div class=\"formview-rightside\"><textarea rows=\"5\" id=\"aq_block_27_tabs-1-quote\" class=\"textarea-full\" name=\"aq_blocks[aq_block_27][tabs][1][quote]\">Be yourself; everyone else is already taken.</textarea>Enter P tags for new lines. eg. <code>&lt;p&gt;Line 1&lt;/p&gt;&lt;p&gt;Line 2&lt;/p&gt;</code></div><p></p>			</div>
		</li>
			<li id=\"aq_block_27_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							George Eliot						</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_27_tabs-2-name\">Client Name</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_27_tabs-2-name\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][2][name]\" value=\"George Eliot\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_27_tabs-2-company\">Company</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_27_tabs-2-company\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][2][company]\" value=\"\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_27_tabs-2-link\">Company link</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_27_tabs-2-link\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][2][link]\" value=\"\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_27_tabs-2-image\">Image</label>
						</div>
						<div class=\"formview-rightside\"><img class=\"screenshot\" src=\"\" alt=\"\"><input id=\"aq_block_27_tabs-2-imageid\" name=\"aq_blocks[aq_block_27][tabs][2][imageid]\" value=\"\" type=\"hidden\"><input id=\"aq_block_27_tabs-2-image\" readonly=\"\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_27][tabs][2][image]\" type=\"text\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a href=\"#\" class=\"remove_image button\" rel=\"image\">Remove</a></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_27_tabs-2-quote\">Quote</label>
						</div>
						<div class=\"formview-rightside\"><textarea rows=\"5\" id=\"aq_block_27_tabs-2-quote\" class=\"textarea-full\" name=\"aq_blocks[aq_block_27][tabs][2][quote]\">It is never too late to be what you might have been.</textarea>Enter P tags for new lines. eg. <code>&lt;p&gt;Line 1&lt;/p&gt;&lt;p&gt;Line 2&lt;/p&gt;</code></div><p></p>			</div>
		</li>
			<li id=\"aq_block_27_tabs-sortable-item-3\" class=\"sortable-item ui-sortable-handle\" rel=\"3\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Pablo Picasso						</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_27_tabs-3-name\">Client Name</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_27_tabs-3-name\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][3][name]\" value=\"Pablo Picasso\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_27_tabs-3-company\">Company</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_27_tabs-3-company\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][3][company]\" value=\"\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_27_tabs-3-link\">Company link</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_27_tabs-3-link\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][3][link]\" value=\"\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_27_tabs-3-image\">Image</label>
						</div>
						<div class=\"formview-rightside\"><img class=\"screenshot\" src=\"\" alt=\"\"><input id=\"aq_block_27_tabs-3-imageid\" name=\"aq_blocks[aq_block_27][tabs][3][imageid]\" value=\"\" type=\"hidden\"><input id=\"aq_block_27_tabs-3-image\" readonly=\"\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_27][tabs][3][image]\" type=\"text\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a href=\"#\" class=\"remove_image button\" rel=\"image\">Remove</a></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_27_tabs-3-quote\">Quote</label>
						</div>
						<div class=\"formview-rightside\"><textarea rows=\"5\" id=\"aq_block_27_tabs-3-quote\" class=\"textarea-full\" name=\"aq_blocks[aq_block_27][tabs][3][quote]\">Everything you can imagine is real.</textarea>Enter P tags for new lines. eg. <code>&lt;p&gt;Line 1&lt;/p&gt;&lt;p&gt;Line 2&lt;/p&gt;</code></div><p></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"testimonial\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_27][id_base]\" value=\"em_testimonials\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_27][name]\" value=\"Testimonials\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_27][order]\" value=\"2\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_27][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_27][parent]\" value=\"7\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_27][number]\" value=\"27\" 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-25\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" name=\"aq_blocks[aq_block_25][blockID]\" value=\"customers\" id=\"blockID\" type=\"text\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" name=\"aq_blocks[aq_block_25][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_25_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_25_container_type\" name=\"aq_blocks[aq_block_25][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_25_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_25_text_intensity\" name=\"aq_blocks[aq_block_25][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_25_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_25_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_25][margin_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_25_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_25_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_25][margin_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_25_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_25_padding_top\" class=\"input-text-full\" value=\"110\" name=\"aq_blocks[aq_block_25][padding_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_25_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_25_padding_bottom\" class=\"input-text-full\" value=\"110\" name=\"aq_blocks[aq_block_25][padding_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_25_padding_sides\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_25_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_25][padding_sides]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_25_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(242, 242, 242);\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_25_background_color\" class=\"input-color-picker wp-color-picker\" value=\"#f2f2f2\" name=\"aq_blocks[aq_block_25][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: 10.85px;\"><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(242, 242, 242), rgb(242, 242, 242), rgb(242, 242, 242), rgb(242, 242, 242), rgb(242, 242, 242), rgb(242, 242, 242), rgb(242, 242, 242), rgb(242, 242, 242), rgb(242, 242, 242), rgb(242, 242, 242), rgb(242, 242, 242), rgb(242, 242, 242), rgb(242, 242, 242));\"><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_25_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_25_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_25][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_25_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_25_gradient_angle\" name=\"aq_blocks[aq_block_25][gradient_angle]\"><option value=\"none\">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-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_25_background_image\">Background Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_25_background_image_imageid\" name=\"aq_blocks[aq_block_25][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_25_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_25][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_25_background_scroll\">Scroll effect</label>
							<span class=\"forminputdescription\">
								Scroll effect
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_25_background_scroll\" name=\"aq_blocks[aq_block_25][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</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_25][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_25][name]\" value=\"Fullwidth Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_25][order]\" value=\"7\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_25][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_25][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_25][number]\" value=\"25\" type=\"hidden\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
		<li id=\"template-block-28\" class=\"block block-em_column_block ui-resizable mtheme-columns span6\" 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-28\" 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\">6/12</div><span class=\"user-control-id\">contactus</span>
					<div class=\"blocknote-self\"></div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-28\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-29\" class=\"block block-em_displayshortcode span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-29\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"29\" data-mblocktype=\"em_displayshortcode\" 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(0,116,217,0.3) 0%, rgba(0,116,217,1) 100%);
background: -webkit-linear-gradient(left, rgba(0,116,217,0.5) 0%,rgba(0,116,217,1) 100%);
background: linear-gradient(to right, rgba(0,116,217,0.5) 0%,rgba(0,116,217,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#0074D9a5\', endColorstr=\'#0074D9a5\',GradientType=1 );\"><i class=\"simpleicon-energy\"></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\">Shortcode</div><div class=\"block-size\">6/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-29\">						  <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\">Shortcode</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_29][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_29][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-29\">
						<div class=\"description mtheme-input-type-is-textarea\"><div class=\"formview-leftside\">
							<label for=\"aq_block_29_mtheme_shortcode\">Shortcode</label>
							<span class=\"forminputdescription\">
								Shortcode to generate
							</span>
						</div><div class=\"formview-rightside textarea\"><textarea id=\"aq_block_29_mtheme_shortcode\" class=\"textarea- \" name=\"aq_blocks[aq_block_29][mtheme_shortcode]\" rows=\"10\">[contact-form-7 id=\"6085\" title=\"Contact form 1\"]</textarea>Enter P tags for new lines. eg. <code>&lt;p&gt;Line 1&lt;/p&gt;&lt;p&gt;Line 2&lt;/p&gt;</code></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_29][id_base]\" value=\"em_displayshortcode\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_29][name]\" value=\"Shortcode\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_29][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_29][size]\" value=\"span6\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_29][parent]\" value=\"8\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_29][number]\" value=\"29\" 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-28\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" name=\"aq_blocks[aq_block_28][blockID]\" value=\"contactus\" id=\"blockID\" type=\"text\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" name=\"aq_blocks[aq_block_28][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_28_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_28_container_type\" name=\"aq_blocks[aq_block_28][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_28_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_28_text_intensity\" name=\"aq_blocks[aq_block_28][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_28_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_28_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_28][margin_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_28_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_28_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_28][margin_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_28_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_28_padding_top\" class=\"input-text-full\" value=\"120\" name=\"aq_blocks[aq_block_28][padding_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_28_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_28_padding_bottom\" class=\"input-text-full\" value=\"120\" name=\"aq_blocks[aq_block_28][padding_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_28_padding_sides\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_28_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_28][padding_sides]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_28_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_28_background_color\" class=\"input-color-picker wp-color-picker\" value=\"#ffffff\" name=\"aq_blocks[aq_block_28][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_28_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_28_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_28][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_28_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_28_gradient_angle\" name=\"aq_blocks[aq_block_28][gradient_angle]\"><option value=\"none\">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-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_28_background_image\">Background Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_28_background_image_imageid\" name=\"aq_blocks[aq_block_28][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_28_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_28][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_28_background_scroll\">Scroll effect</label>
							<span class=\"forminputdescription\">
								Scroll effect
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_28_background_scroll\" name=\"aq_blocks[aq_block_28][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</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_28][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_28][name]\" value=\"Fullwidth Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_28][order]\" value=\"8\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_28][size]\" value=\"span6\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_28][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_28][number]\" value=\"28\" type=\"hidden\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
		<li id=\"template-block-30\" class=\"block block-em_column_block ui-resizable mtheme-columns span6\" 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-30\" 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\">6/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-30\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-31\" class=\"block block-em_sectionheading span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-31\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"31\" 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\">6/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-31\">						  <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_31][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_31][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-31\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_31_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_31_mtheme_animated\" name=\"aq_blocks[aq_block_31][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_31_mtheme_title\">Section Heading text</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_31_mtheme_title\" class=\"input-text-full\" value=\"Contact us\" name=\"aq_blocks[aq_block_31][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_31_mtheme_subtitle\">Section subtitle (optional)</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_31_mtheme_subtitle\" class=\"input-text-full\" value=\"We\'d love to hear from you\" name=\"aq_blocks[aq_block_31][mtheme_subtitle]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_31_mtheme_align\">Align text</label>
							<span class=\"forminputdescription\">
								Align text
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_31_mtheme_align\" name=\"aq_blocks[aq_block_31][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</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_31_mtheme_size\">Heading size</label>
							<span class=\"forminputdescription\">
								Heading size
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_31_mtheme_size\" name=\"aq_blocks[aq_block_31][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-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_31_mtheme_content_richtext\">Content</label>
							<span class=\"forminputdescription\">
								Add content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_31_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_31_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_31][mtheme_content_richtext]\" id=\"aq_block_31_mtheme_content_richtext\">&lt;p&gt;Integer sed tincidunt dui. Cras tincidunt at risus vitae ultrices. Sed at placerat diam. Nam ornare feugiat blandit. Suspendisse potenti.&lt;/p&gt;</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_31_mtheme_button\">Button Text</label>
							<span class=\"forminputdescription\">
								Button Text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_31_mtheme_button\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_31][mtheme_button]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_31_mtheme_button_link\">Button link</label>
							<span class=\"forminputdescription\">
								Button link
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_31_mtheme_button_link\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_31][mtheme_button_link]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_31_mtheme_width\">Width in percent</label>
							<span class=\"forminputdescription\">
								Width in percent
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_31_mtheme_width\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_31][mtheme_width]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_31_mtheme_top\">Padding Top in pixels</label>
							<span class=\"forminputdescription\">
								Top Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_31_mtheme_top\" class=\"input-text-full\" value=\"0\" name=\"aq_blocks[aq_block_31][mtheme_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_31_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"forminputdescription\">
								Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_31_mtheme_bottom\" class=\"input-text-full\" value=\"0\" name=\"aq_blocks[aq_block_31][mtheme_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_31_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"forminputdescription\">
								Margin Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_31_mtheme_marginbottom\" class=\"input-text-full\" value=\"15\" name=\"aq_blocks[aq_block_31][mtheme_marginbottom]\" type=\"text\"></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_31][id_base]\" value=\"em_sectionheading\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_31][name]\" value=\"Section Heading\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_31][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_31][size]\" value=\"span6\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_31][parent]\" value=\"9\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_31][number]\" value=\"31\" 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-32\" class=\"block block-em_displayrichtext span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-32\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"32\" data-mblocktype=\"em_displayrichtext\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(225,164,60,0.3) 0%, rgba(225,164,60,1) 100%);
background: -webkit-linear-gradient(left, rgba(225,164,60,0.5) 0%,rgba(225,164,60,1) 100%);
background: linear-gradient(to right, rgba(225,164,60,0.5) 0%,rgba(225,164,60,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#E1A43Ca5\', endColorstr=\'#E1A43Ca5\',GradientType=1 );\"><i class=\"simpleicon-pencil\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Richtext Box</div><div class=\"block-size\">6/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-32\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Richtext Box</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_32][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_32][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-32\">
						<div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_32_mtheme_content_richtext\">Rich Text</label>
							<span class=\"forminputdescription\">
								Add the content
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_32_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_32_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_32][mtheme_content_richtext]\" id=\"aq_block_32_mtheme_content_richtext\">&lt;h4 style=\"text-align: center;\"&gt;Our Office&lt;/h4&gt;
&lt;p style=\"text-align: center;\"&gt;198&nbsp; West 21th Street, Suite 721&lt;br /&gt;New York, NY 10010&lt;br /&gt;Email: youremail@yourdomain.com&lt;br /&gt;Phone: +88 (0) 101 0000 000&lt;br /&gt;Fax: +88 (0) 202 0000 001&lt;/p&gt;</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_32][id_base]\" value=\"em_displayrichtext\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_32][name]\" value=\"Richtext Box\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_32][order]\" value=\"2\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_32][size]\" value=\"span6\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_32][parent]\" value=\"9\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_32][number]\" value=\"32\" 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-30\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" name=\"aq_blocks[aq_block_30][blockID]\" value=\"\" id=\"blockID\" type=\"text\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" name=\"aq_blocks[aq_block_30][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_30_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_30_container_type\" name=\"aq_blocks[aq_block_30][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_30_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_30_text_intensity\" name=\"aq_blocks[aq_block_30][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_30_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_30_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_30][margin_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_30_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_30_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_30][margin_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_30_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_30_padding_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_30][padding_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_30_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_30_padding_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_30][padding_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_30_padding_sides\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_30_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_30][padding_sides]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_30_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_30_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_30][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_30_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_30_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_30][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_30_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_30_gradient_angle\" name=\"aq_blocks[aq_block_30][gradient_angle]\"><option value=\"none\">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-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_30_background_image\">Background Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_30_background_image_imageid\" name=\"aq_blocks[aq_block_30][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_30_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_30][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_30_background_scroll\">Scroll effect</label>
							<span class=\"forminputdescription\">
								Scroll effect
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_30_background_scroll\" name=\"aq_blocks[aq_block_30][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</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_30][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_30][name]\" value=\"Fullwidth Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_30][order]\" value=\"9\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_30][size]\" value=\"span6\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_30][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_30][number]\" value=\"30\" type=\"hidden\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
		<li id=\"template-block-33\" 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-33\" 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\">Map</div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-33\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-34\" class=\"block block-em_googlemap 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-34\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"34\" data-mblocktype=\"em_googlemap\" 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=\"simpleicon-pointer\"></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\">Google Map</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-34\">						  <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\">Google Map</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_34][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_34][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-34\">
						<div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_34_mtheme_map_type\">Map Type</label>
							<span class=\"forminputdescription\">
								Map Type
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_34_mtheme_map_type\" name=\"aq_blocks[aq_block_34][mtheme_map_type]\"><option value=\"ROADMAP\" selected=\"selected\">roadmap</option><option value=\"SATELLITE\">satellite</option><option value=\"HYBRID\">hybrid</option><option value=\"TERRAIN\">terrain</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_34_mtheme_map_style\">Map Style</label>
							<span class=\"forminputdescription\">
								Map Style
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_34_mtheme_map_style\" name=\"aq_blocks[aq_block_34][mtheme_map_style]\"><option value=\"desaturated\" selected=\"selected\">Desaturated</option><option value=\"lightdream\">Light Dream</option><option value=\"shadesofgrey\">Shades of Grey</option><option value=\"applemaps\">Apple Maps</option><option value=\"lightmonochrome\">Light Monochrome</option><option value=\"mapbox\">Map Box</option><option value=\"gowalla\">Gowalla</option><option value=\"cleancut\">Clean Cut</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_34_mtheme_map_address\">Map Address</label>
							<span class=\"forminputdescription\">
								Map Address
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_34_mtheme_map_address\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_34][mtheme_map_address]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_34_mtheme_map_height\">Map Height</label>
							<span class=\"forminputdescription\">
								Map Height
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_34_mtheme_map_height\" class=\"input-text-full\" value=\"600\" name=\"aq_blocks[aq_block_34][mtheme_map_height]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_34_mtheme_map_latitude\">Map Latitude</label>
							<span class=\"forminputdescription\">
								Set 0 if you want to don\'t want to use the field. Map Latitude
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_34_mtheme_map_latitude\" class=\"input-text-full\" value=\"48.88532\" name=\"aq_blocks[aq_block_34][mtheme_map_latitude]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_34_mtheme_map_longitude\">Map Longitude</label>
							<span class=\"forminputdescription\">
								Set 0 if you want to don\'t want to use the field. Map Longitude
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_34_mtheme_map_longitude\" class=\"input-text-full\" value=\"2.15479\" name=\"aq_blocks[aq_block_34][mtheme_map_longitude]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_34_mtheme_map_marker\">Map Marker</label>
							<span class=\"forminputdescription\">
								Map Marker
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_34_mtheme_map_marker\" name=\"aq_blocks[aq_block_34][mtheme_map_marker]\"><option value=\"yes\" selected=\"selected\">Yes</option><option value=\"no\">No</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_34_mtheme_map_zoom\">Map Zoom (1 to 20)</label>
							<span class=\"forminputdescription\">
								Map Height
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_34_mtheme_map_zoom\" class=\"input-text-full\" value=\"15\" name=\"aq_blocks[aq_block_34][mtheme_map_zoom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_34_mtheme_map_scroll\">Mouse Scroll</label>
							<span class=\"forminputdescription\">
								Mouse Scroll
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_34_mtheme_map_scroll\" name=\"aq_blocks[aq_block_34][mtheme_map_scroll]\"><option value=\"true\">True</option><option value=\"false\" selected=\"selected\">False</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_34_mtheme_map_control\">Map Controls</label>
							<span class=\"forminputdescription\">
								Map Controls
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_34_mtheme_map_control\" name=\"aq_blocks[aq_block_34][mtheme_map_control]\"><option value=\"true\" selected=\"selected\">True</option><option value=\"false\">False</option></select></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_34_mtheme_map_marker_image\">Image as marker</label>
							<span class=\"forminputdescription\">
								Image as marker
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_34_mtheme_map_marker_image_imageid\" name=\"aq_blocks[aq_block_34][mtheme_map_marker_imageid]\" value=\"10\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_34_mtheme_map_marker_image\" class=\"input-full imagefile-uploader\" value=\"http://kinetika-freelance.imaginem.co/wp-content/uploads/sites/11/2015/09/google-map-pointer.png\" name=\"aq_blocks[aq_block_34][mtheme_map_marker_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-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_34_mtheme_map_marker_text\">Marker text</label>
							<span class=\"forminputdescription\">
								Marker text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_34_mtheme_map_marker_text\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_34][mtheme_map_marker_text]\" type=\"text\"></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_34][id_base]\" value=\"em_googlemap\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_34][name]\" value=\"Google Map\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_34][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_34][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_34][parent]\" value=\"10\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_34][number]\" value=\"34\" 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-33\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" name=\"aq_blocks[aq_block_33][blockID]\" value=\"\" id=\"blockID\" type=\"text\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" name=\"aq_blocks[aq_block_33][blockNote]\" value=\"Map\" 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_33_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_33_container_type\" name=\"aq_blocks[aq_block_33][container_type]\"><option value=\"boxed\">Boxed</option><option value=\"fullwidth\" selected=\"selected\">Fullwidth</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_33_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_33_text_intensity\" name=\"aq_blocks[aq_block_33][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_33_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_33_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_33][margin_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_33_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_33_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_33][margin_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_33_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_33_padding_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_33][padding_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_33_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_33_padding_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_33][padding_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_33_padding_sides\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_33_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_33][padding_sides]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_33_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_33_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_33][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_33_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_33_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_33][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_33_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_33_gradient_angle\" name=\"aq_blocks[aq_block_33][gradient_angle]\"><option value=\"none\">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-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_33_background_image\">Background Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_33_background_image_imageid\" name=\"aq_blocks[aq_block_33][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_33_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_33][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_33_background_scroll\">Scroll effect</label>
							<span class=\"forminputdescription\">
								Scroll effect
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_33_background_scroll\" name=\"aq_blocks[aq_block_33][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</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_33][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_33][name]\" value=\"Fullwidth Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_33][order]\" value=\"10\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_33][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_33][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_33][number]\" value=\"33\" type=\"hidden\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
									