
								<li style=\"top: auto; left: 0px;\" id=\"template-block-1\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\"><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:#2E99E6;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</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 style=\"top: auto; left: 0px;\" id=\"template-block-2\" class=\"block block-em_sectionheading span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Section Heading\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-2\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"2\" data-mblocktype=\"em_sectionheading\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"color:#2E99E6;\"><i class=\"fa fa-header\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Section Heading</div><div class=\"block-size\">12/12</div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-2\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Section Heading</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_2][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-2\">
						<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_2_mtheme_animated\" name=\"aq_blocks[aq_block_2][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_title\">Section Heading text</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_2_mtheme_title\" class=\"input-text-full\" value=\"Brief History\" name=\"aq_blocks[aq_block_2][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_subtitle\">Section subtitle (optional)</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_2_mtheme_subtitle\" class=\"input-text-full\" value=\"Our accomplishments\" name=\"aq_blocks[aq_block_2][mtheme_subtitle]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_align\">Align text</label>
							<span class=\"description_text\">
								Align text
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_2_mtheme_align\" name=\"aq_blocks[aq_block_2][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_size\">Heading size</label>
							<span class=\"description_text\">
								Heading size
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_2_mtheme_size\" name=\"aq_blocks[aq_block_2][mtheme_size]\"><option value=\"1\" selected=\"selected\">h1</option><option value=\"2\">h2</option><option value=\"3\">h3</option><option value=\"4\">h4</option><option value=\"5\">h5</option><option value=\"6\">h6</option></select></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_content_richtext\">Content</label>
							<span class=\"description_text\">
								Add content
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_2_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_2_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_2][mtheme_content_richtext]\" id=\"aq_block_2_mtheme_content_richtext\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_button\">Button Text</label>
							<span class=\"description_text\">
								Button Text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_2_mtheme_button\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_2][mtheme_button]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_button_link\">Button link</label>
							<span class=\"description_text\">
								Button link
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_2_mtheme_button_link\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_2][mtheme_button_link]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_width\">Width in percent</label>
							<span class=\"description_text\">
								Width in percent
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_2_mtheme_width\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_2][mtheme_width]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_top\">Padding Top in pixels</label>
							<span class=\"description_text\">
								Top Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_2_mtheme_top\" class=\"input-text-full\" value=\"180\" name=\"aq_blocks[aq_block_2][mtheme_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"description_text\">
								Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_2_mtheme_bottom\" class=\"input-text-full\" value=\"30\" name=\"aq_blocks[aq_block_2][mtheme_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_2_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"description_text\">
								Margin Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_2_mtheme_marginbottom\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_2][mtheme_marginbottom]\" type=\"text\"></span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_2][id_base]\" value=\"em_sectionheading\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_2][name]\" value=\"Section Heading\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_2][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_2][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_2][parent]\" value=\"1\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_2][number]\" value=\"2\" type=\"hidden\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-3\" class=\"block block-em_displayrichtext span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Richtext\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-3\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"3\" data-mblocktype=\"em_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=\"color:#2E99E6;\"><i class=\"fa fa-text-height\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Richtext Box</div><div class=\"block-size\">6/12</div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-3\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Richtext Box</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_3][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-3\">
						<div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_3_mtheme_content_richtext\">Rich Text</label>
							<span class=\"description_text\">
								Add the content
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_3_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_3_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_3][mtheme_content_richtext]\" id=\"aq_block_3_mtheme_content_richtext\">&lt;h2&gt;Portfolio &amp; Description&lt;/h2&gt;
&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;br /&gt;&lt;br /&gt;Integer sed tincidunt dui. Cras tincidunt at risus vitae ultrices. Sed at placerat diam. Nam ornare feugiat blandit. Suspendisse potenti. Nam et finibus elit. Integer ac turpis quam. Pellentesque eleifend ipsum a magna rhoncus, eu laoreet ipsum dapibus. Morbi pellentesque, nunc at pulvinar fringilla, nunc risus iaculis enim, finibus ornare turpis sem quis ex. Maecenas tristique varius orci vel eleifend. Sed tempor erat id mi tempor efficitur.&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>

</span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_3][id_base]\" value=\"em_displayrichtext\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_3][name]\" value=\"Richtext Box\" 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=\"span6\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_3][parent]\" value=\"1\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_3][number]\" value=\"3\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-4\" class=\"block block-em_progressbar span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Progress Bar\"><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_progressbar\" 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=\"color:#2E99E6;\"><i class=\"fa fa-minus\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Progress bar</div><div class=\"block-size\">6/12</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\">Progress bar</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_4][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-4\">
									<div class=\"description cf\">
						
				<ul id=\"aq-sortable-list-aq_block_4\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_4\">
								<li id=\"aq_block_4_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Projects						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-1-title\">Progress Bar title</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_4_tabs-1-title\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][1][title]\" value=\"Projects\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-1-unit\">Display unit</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_4_tabs-1-unit\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][1][unit]\" value=\"%\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-1-color\">Progress color</label>
						</span>
						<span class=\"rightHalf\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" style=\"background-color: rgb(254, 70, 65);\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_4_tabs-1-color\" class=\"input-color-picker wp-color-picker\" value=\"#fe4641\" name=\"aq_blocks[aq_block_4][tabs][1][color]\" data-default-color=\"#fe4641\" type=\"text\"><input value=\"Default\" class=\"button button-small hidden wp-picker-default\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 1.01185px; top: 0px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , rgb(255, 66, 66), rgb(255, 160, 66), rgb(255, 255, 66), rgb(160, 255, 66), rgb(66, 255, 66), rgb(66, 255, 160), rgb(66, 255, 254), rgb(66, 160, 255), rgb(66, 66, 255), rgb(160, 66, 255), rgb(254, 66, 255), rgb(255, 66, 160), rgb(255, 66, 66));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(255, 8, 0), rgb(255, 255, 255));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 74%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-1-percentage\">Percent Value</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_4_tabs-1-percentage\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][1][percentage]\" value=\"55\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_4_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							In Process						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-2-title\">Progress Bar title</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_4_tabs-2-title\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][2][title]\" value=\"In Process\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-2-unit\">Display unit</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_4_tabs-2-unit\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][2][unit]\" value=\"%\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-2-color\">Progress color</label>
						</span>
						<span class=\"rightHalf\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" style=\"background-color: rgb(254, 70, 65);\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_4_tabs-2-color\" class=\"input-color-picker wp-color-picker\" value=\"#fe4641\" name=\"aq_blocks[aq_block_4][tabs][2][color]\" data-default-color=\"#fe4641\" type=\"text\"><input value=\"Default\" class=\"button button-small hidden wp-picker-default\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 1.01185px; top: 0px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , rgb(255, 66, 66), rgb(255, 160, 66), rgb(255, 255, 66), rgb(160, 255, 66), rgb(66, 255, 66), rgb(66, 255, 160), rgb(66, 255, 254), rgb(66, 160, 255), rgb(66, 66, 255), rgb(160, 66, 255), rgb(254, 66, 255), rgb(255, 66, 160), rgb(255, 66, 66));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(255, 8, 0), rgb(255, 255, 255));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 74%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-2-percentage\">Percent Value</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_4_tabs-2-percentage\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][2][percentage]\" value=\"60\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_4_tabs-sortable-item-3\" class=\"sortable-item ui-sortable-handle\" rel=\"3\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Completed						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-3-title\">Progress Bar title</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_4_tabs-3-title\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][3][title]\" value=\"Completed\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-3-unit\">Display unit</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_4_tabs-3-unit\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][3][unit]\" value=\"%\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-3-color\">Progress color</label>
						</span>
						<span class=\"rightHalf\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" style=\"background-color: rgb(254, 70, 65);\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_4_tabs-3-color\" class=\"input-color-picker wp-color-picker\" value=\"#fe4641\" name=\"aq_blocks[aq_block_4][tabs][3][color]\" data-default-color=\"#fe4641\" type=\"text\"><input value=\"Default\" class=\"button button-small hidden wp-picker-default\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 1.01185px; top: 0px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , rgb(255, 66, 66), rgb(255, 160, 66), rgb(255, 255, 66), rgb(160, 255, 66), rgb(66, 255, 66), rgb(66, 255, 160), rgb(66, 255, 254), rgb(66, 160, 255), rgb(66, 66, 255), rgb(160, 66, 255), rgb(254, 66, 255), rgb(255, 66, 160), rgb(255, 66, 66));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(255, 8, 0), rgb(255, 255, 255));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 74%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-3-percentage\">Percent Value</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_4_tabs-3-percentage\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][3][percentage]\" value=\"80\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_4_tabs-sortable-item-4\" class=\"sortable-item ui-sortable-handle\" rel=\"4\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Undertaken						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-4-title\">Progress Bar title</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_4_tabs-4-title\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][4][title]\" value=\"Undertaken\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-4-unit\">Display unit</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_4_tabs-4-unit\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][4][unit]\" value=\"%\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-4-color\">Progress color</label>
						</span>
						<span class=\"rightHalf\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" style=\"background-color: rgb(254, 70, 65);\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_4_tabs-4-color\" class=\"input-color-picker wp-color-picker\" value=\"#fe4641\" name=\"aq_blocks[aq_block_4][tabs][4][color]\" data-default-color=\"#fe4641\" type=\"text\"><input value=\"Default\" class=\"button button-small hidden wp-picker-default\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 1.01185px; top: 0px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , rgb(255, 66, 66), rgb(255, 160, 66), rgb(255, 255, 66), rgb(160, 255, 66), rgb(66, 255, 66), rgb(66, 255, 160), rgb(66, 255, 254), rgb(66, 160, 255), rgb(66, 66, 255), rgb(160, 66, 255), rgb(254, 66, 255), rgb(255, 66, 160), rgb(255, 66, 66));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(255, 8, 0), rgb(255, 255, 255));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 74%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-4-percentage\">Percent Value</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_4_tabs-4-percentage\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][4][percentage]\" value=\"50\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_4_tabs-sortable-item-5\" class=\"sortable-item ui-sortable-handle\" rel=\"5\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Coffee						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-5-title\">Progress Bar title</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_4_tabs-5-title\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][5][title]\" value=\"Coffee\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-5-unit\">Display unit</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_4_tabs-5-unit\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][5][unit]\" value=\"%\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-5-color\">Progress color</label>
						</span>
						<span class=\"rightHalf\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" style=\"background-color: rgb(254, 70, 65);\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_4_tabs-5-color\" class=\"input-color-picker wp-color-picker\" value=\"#fe4641\" name=\"aq_blocks[aq_block_4][tabs][5][color]\" data-default-color=\"#fe4641\" type=\"text\"><input value=\"Default\" class=\"button button-small hidden wp-picker-default\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 1.01185px; top: 0px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , rgb(255, 66, 66), rgb(255, 160, 66), rgb(255, 255, 66), rgb(160, 255, 66), rgb(66, 255, 66), rgb(66, 255, 160), rgb(66, 255, 254), rgb(66, 160, 255), rgb(66, 66, 255), rgb(160, 66, 255), rgb(254, 66, 255), rgb(255, 66, 160), rgb(255, 66, 66));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(255, 8, 0), rgb(255, 255, 255));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 74%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_4_tabs-5-percentage\">Percent Value</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_4_tabs-5-percentage\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][5][percentage]\" value=\"65\" type=\"text\"></span></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"progressbar\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_4][id_base]\" value=\"em_progressbar\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_4][name]\" value=\"Progress bar\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_4][order]\" value=\"3\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_4][size]\" value=\"span6\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_4][parent]\" value=\"1\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></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\">Block ID</label><input class=\"blockID\" name=\"aq_blocks[aq_block_1][blockID]\" value=\"\" id=\"blockID\" type=\"text\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_container_type\">Boxed or Fullwidth</label>
							<span class=\"description_text\">
								Boxed or Fullwidth. For full columns
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_1_container_type\" name=\"aq_blocks[aq_block_1][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_text_intensity\">Text Intensity</label>
							<span class=\"description_text\">
								Text Intensity for headings types
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_1_text_intensity\" name=\"aq_blocks[aq_block_1][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_margin_top\">Margin top in pixels</label>
							<span class=\"description_text\">
								Margin top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_1_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][margin_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"description_text\">
								Margin bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_1_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][margin_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_padding_top\">Padding top in pixels</label>
							<span class=\"description_text\">
								Padding top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_1_padding_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][padding_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"description_text\">
								Padding bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_1_padding_bottom\" class=\"input-text-full\" value=\"80\" name=\"aq_blocks[aq_block_1][padding_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_padding_sides\">Padding sides in pixels</label>
							<span class=\"description_text\">
								Padding sides in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_1_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][padding_sides]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_background_color\">Background color</label>
							<span class=\"description_text\">
								Background color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" 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=\"\" type=\"text\"><input value=\"Clear\" class=\"button button-small hidden wp-picker-clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 0px; top: 182.133px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , 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));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 0%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_background_image\">Background Image</label>
							<span class=\"description_text\">
								Background Image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" 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 input-upload\" 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></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_1_background_scroll\">Scroll effect</label>
							<span class=\"description_text\">
								Scroll effect
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_1_background_scroll\" name=\"aq_blocks[aq_block_1][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</option></select></span></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_1][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_1][name]\" value=\"Fullwidth Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_1][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_1][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_1][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_1][number]\" value=\"1\" type=\"hidden\">				</div>
			<div style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li>
		<li style=\"top: auto; left: 0px;\" id=\"template-block-5\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\"><dl class=\"block-bar\">
				<ul class=\"block-controls\">
					<li class=\"block-control-actions cf\">
						<a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove Column Container\"><i class=\"fa fa-trash\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#my-column-content-5\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit Column Container\"><i class=\"fa fa-pencil\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\" data-toggle=\"modal\"><i class=\"fa fa-upload\"></i></a>
					</li>
				</ul>
				<dt class=\"block-handle ui-sortable-handle\">
	 				<div class=\"block-icon\" style=\"color:#2E99E6;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-5\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li style=\"top: auto; left: 0px;\" id=\"template-block-6\" class=\"block block-em_sectionheading span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Section Heading\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-6\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"6\" data-mblocktype=\"em_sectionheading\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"color:#2E99E6;\"><i class=\"fa fa-header\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Section Heading</div><div class=\"block-size\">12/12</div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-6\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Section Heading</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_6][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-6\">
						<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_6_mtheme_animated\" name=\"aq_blocks[aq_block_6][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_title\">Section Heading text</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_6_mtheme_title\" class=\"input-text-full\" value=\"Meet the Team\" name=\"aq_blocks[aq_block_6][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_subtitle\">Section subtitle (optional)</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_6_mtheme_subtitle\" class=\"input-text-full\" value=\"The company talents\" name=\"aq_blocks[aq_block_6][mtheme_subtitle]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_align\">Align text</label>
							<span class=\"description_text\">
								Align text
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_6_mtheme_align\" name=\"aq_blocks[aq_block_6][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_size\">Heading size</label>
							<span class=\"description_text\">
								Heading size
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_6_mtheme_size\" name=\"aq_blocks[aq_block_6][mtheme_size]\"><option value=\"1\">h1</option><option value=\"2\" selected=\"selected\">h2</option><option value=\"3\">h3</option><option value=\"4\">h4</option><option value=\"5\">h5</option><option value=\"6\">h6</option></select></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_content_richtext\">Content</label>
							<span class=\"description_text\">
								Add content
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_6_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_6_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_6][mtheme_content_richtext]\" id=\"aq_block_6_mtheme_content_richtext\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_button\">Button Text</label>
							<span class=\"description_text\">
								Button Text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_6_mtheme_button\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_6][mtheme_button]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_button_link\">Button link</label>
							<span class=\"description_text\">
								Button link
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_6_mtheme_button_link\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_6][mtheme_button_link]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_width\">Width in percent</label>
							<span class=\"description_text\">
								Width in percent
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_6_mtheme_width\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_6][mtheme_width]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_top\">Padding Top in pixels</label>
							<span class=\"description_text\">
								Top Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_6_mtheme_top\" class=\"input-text-full\" value=\"50\" name=\"aq_blocks[aq_block_6][mtheme_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"description_text\">
								Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_6_mtheme_bottom\" class=\"input-text-full\" value=\"10\" name=\"aq_blocks[aq_block_6][mtheme_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_6_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"description_text\">
								Margin Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_6_mtheme_marginbottom\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_6][mtheme_marginbottom]\" type=\"text\"></span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_6][id_base]\" value=\"em_sectionheading\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_6][name]\" value=\"Section Heading\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_6][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_6][size]\" value=\"span12\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-7\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Staff Blocks\"><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_staff\" 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=\"color:#2E99E6;\"><i class=\"fa fa-user\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</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\">Staff</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_7][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-7\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf 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\" 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></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_mtheme_title\">Staff title</label>
							<span class=\"description_text\">
								Staff title
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_7_mtheme_title\" class=\"input-text-full\" value=\"Production Deisgner\" name=\"aq_blocks[aq_block_7][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_mtheme_name\">Staff name</label>
							<span class=\"description_text\">
								Staff name
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_7_mtheme_name\" class=\"input-text-full\" value=\"John Doe\" name=\"aq_blocks[aq_block_7][mtheme_name]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_mtheme_image\">Staff image</label>
							<span class=\"description_text\">
								Staff image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_7_mtheme_image_imageid\" name=\"aq_blocks[aq_block_7][mtheme_imageid]\" value=\"7566\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_7_mtheme_image\" class=\"input-full input-upload\" value=\"http://placehold.it/406x406/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_7][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></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_7_mtheme_description\">Staff Description</label>
							<span class=\"description_text\">
								Staff Description
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_7_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_7_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_7][mtheme_description]\" id=\"aq_block_7_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div>			
				<ul id=\"aq-sortable-list-aq_block_7\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_7\">
								<li id=\"aq_block_7_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Facebook						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_7_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_7_tabs-1-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_7][tabs][1][social_icon]\" value=\"fa fa-facebook\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-facebook\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_7_tabs-1-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_7_tabs-1-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_7][tabs][1][social_text]\" value=\"Facebook\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_7_tabs-1-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_7_tabs-1-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_7][tabs][1][social_link]\" value=\"http://www.facebook.com/\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_7_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Twitter						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_7_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_7_tabs-2-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_7][tabs][2][social_icon]\" value=\"fa fa-twitter\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-twitter\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_7_tabs-2-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_7_tabs-2-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_7][tabs][2][social_text]\" value=\"Twitter\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_7_tabs-2-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_7_tabs-2-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_7][tabs][2][social_link]\" value=\"http://www.twitter.com/\" type=\"text\"></span></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"staff\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_7][id_base]\" value=\"em_staff\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_7][name]\" value=\"Staff\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_7][order]\" value=\"2\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-8\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Staff Blocks\"><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_staff\" 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=\"color:#2E99E6;\"><i class=\"fa fa-user\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</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\">Staff</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_8][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-8\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_8_mtheme_animated\" name=\"aq_blocks[aq_block_8][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\" selected=\"selected\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_title\">Staff title</label>
							<span class=\"description_text\">
								Staff title
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_8_mtheme_title\" class=\"input-text-full\" value=\"Production Deisgner\" name=\"aq_blocks[aq_block_8][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_name\">Staff name</label>
							<span class=\"description_text\">
								Staff name
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_8_mtheme_name\" class=\"input-text-full\" value=\"John Doe\" name=\"aq_blocks[aq_block_8][mtheme_name]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_image\">Staff image</label>
							<span class=\"description_text\">
								Staff image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_8_mtheme_image_imageid\" name=\"aq_blocks[aq_block_8][mtheme_imageid]\" value=\"7567\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_8_mtheme_image\" class=\"input-full input-upload\" value=\"http://placehold.it/406x406/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_8][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></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_8_mtheme_description\">Staff Description</label>
							<span class=\"description_text\">
								Staff Description
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_8_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_8_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_8][mtheme_description]\" id=\"aq_block_8_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div>			
				<ul id=\"aq-sortable-list-aq_block_8\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_8\">
								<li id=\"aq_block_8_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Facebook						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_8_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_8_tabs-1-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_8][tabs][1][social_icon]\" value=\"fa fa-facebook\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-facebook\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_8_tabs-1-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_8_tabs-1-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_8][tabs][1][social_text]\" value=\"Facebook\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_8_tabs-1-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_8_tabs-1-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_8][tabs][1][social_link]\" value=\"http://www.facebook.com/\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_8_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Twitter						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_8_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_8_tabs-2-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_8][tabs][2][social_icon]\" value=\"fa fa-twitter\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-twitter\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_8_tabs-2-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_8_tabs-2-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_8][tabs][2][social_text]\" value=\"Twitter\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_8_tabs-2-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_8_tabs-2-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_8][tabs][2][social_link]\" value=\"http://www.twitter.com/\" type=\"text\"></span></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"staff\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_8][id_base]\" value=\"em_staff\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_8][name]\" value=\"Staff\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_8][order]\" value=\"3\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_8][size]\" value=\"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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-9\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Staff Blocks\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-9\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"9\" data-mblocktype=\"em_staff\" 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=\"color:#2E99E6;\"><i class=\"fa fa-user\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-9\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Staff</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_9][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-9\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_9_mtheme_animated\" name=\"aq_blocks[aq_block_9][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\" selected=\"selected\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_mtheme_title\">Staff title</label>
							<span class=\"description_text\">
								Staff title
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_9_mtheme_title\" class=\"input-text-full\" value=\"Production Deisgner\" name=\"aq_blocks[aq_block_9][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_mtheme_name\">Staff name</label>
							<span class=\"description_text\">
								Staff name
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_9_mtheme_name\" class=\"input-text-full\" value=\"John Doe\" name=\"aq_blocks[aq_block_9][mtheme_name]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_mtheme_image\">Staff image</label>
							<span class=\"description_text\">
								Staff image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_9_mtheme_image_imageid\" name=\"aq_blocks[aq_block_9][mtheme_imageid]\" value=\"7568\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_9_mtheme_image\" class=\"input-full input-upload\" value=\"http://placehold.it/406x406/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_9][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></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_9_mtheme_description\">Staff Description</label>
							<span class=\"description_text\">
								Staff Description
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_9_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_9_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_9][mtheme_description]\" id=\"aq_block_9_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div>			
				<ul id=\"aq-sortable-list-aq_block_9\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_9\">
								<li id=\"aq_block_9_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Facebook						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_9_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_9_tabs-1-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_9][tabs][1][social_icon]\" value=\"fa fa-facebook\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-facebook\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_9_tabs-1-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_9_tabs-1-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_9][tabs][1][social_text]\" value=\"Facebook\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_9_tabs-1-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_9_tabs-1-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_9][tabs][1][social_link]\" value=\"http://www.facebook.com/\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_9_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Twitter						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_9_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_9_tabs-2-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_9][tabs][2][social_icon]\" value=\"fa fa-twitter\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-twitter\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_9_tabs-2-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_9_tabs-2-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_9][tabs][2][social_text]\" value=\"Twitter\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_9_tabs-2-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_9_tabs-2-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_9][tabs][2][social_link]\" value=\"http://www.twitter.com/\" type=\"text\"></span></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"staff\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_9][id_base]\" value=\"em_staff\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_9][name]\" value=\"Staff\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_9][order]\" value=\"4\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_9][size]\" value=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_9][parent]\" value=\"2\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_9][number]\" value=\"9\" type=\"hidden\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-10\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Staff Blocks\"><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_staff\" 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=\"color:#2E99E6;\"><i class=\"fa fa-user\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</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\">Staff</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_10][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-10\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_10_mtheme_animated\" name=\"aq_blocks[aq_block_10][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">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></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_title\">Staff title</label>
							<span class=\"description_text\">
								Staff title
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_10_mtheme_title\" class=\"input-text-full\" value=\"Production Deisgner\" name=\"aq_blocks[aq_block_10][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_name\">Staff name</label>
							<span class=\"description_text\">
								Staff name
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_10_mtheme_name\" class=\"input-text-full\" value=\"John Doe\" name=\"aq_blocks[aq_block_10][mtheme_name]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_image\">Staff image</label>
							<span class=\"description_text\">
								Staff image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_10_mtheme_image_imageid\" name=\"aq_blocks[aq_block_10][mtheme_imageid]\" value=\"7569\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_10_mtheme_image\" class=\"input-full input-upload\" value=\"http://placehold.it/406x406/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_10][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></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_10_mtheme_description\">Staff Description</label>
							<span class=\"description_text\">
								Staff Description
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_10_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_10_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_10][mtheme_description]\" id=\"aq_block_10_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div>			
				<ul id=\"aq-sortable-list-aq_block_10\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_10\">
								<li id=\"aq_block_10_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Facebook						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_10_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_10_tabs-1-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_10][tabs][1][social_icon]\" value=\"fa fa-facebook\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-facebook\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_10_tabs-1-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_10_tabs-1-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_10][tabs][1][social_text]\" value=\"Facebook\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_10_tabs-1-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_10_tabs-1-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_10][tabs][1][social_link]\" value=\"http://www.facebook.com/\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_10_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Twitter						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_10_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_10_tabs-2-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_10][tabs][2][social_icon]\" value=\"fa fa-twitter\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-twitter\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_10_tabs-2-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_10_tabs-2-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_10][tabs][2][social_text]\" value=\"Twitter\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_10_tabs-2-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_10_tabs-2-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_10][tabs][2][social_link]\" value=\"http://www.twitter.com/\" type=\"text\"></span></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"staff\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_10][id_base]\" value=\"em_staff\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_10][name]\" value=\"Staff\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_10][order]\" value=\"5\" 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=\"2\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-11\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Staff Blocks\"><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_staff\" 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=\"color:#2E99E6;\"><i class=\"fa fa-user\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</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\">Staff</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_11][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-11\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_11_mtheme_animated\" name=\"aq_blocks[aq_block_11][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\" 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></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_title\">Staff title</label>
							<span class=\"description_text\">
								Staff title
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_11_mtheme_title\" class=\"input-text-full\" value=\"Production Deisgner\" name=\"aq_blocks[aq_block_11][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_name\">Staff name</label>
							<span class=\"description_text\">
								Staff name
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_11_mtheme_name\" class=\"input-text-full\" value=\"John Doe\" name=\"aq_blocks[aq_block_11][mtheme_name]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_image\">Staff image</label>
							<span class=\"description_text\">
								Staff image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_11_mtheme_image_imageid\" name=\"aq_blocks[aq_block_11][mtheme_imageid]\" value=\"7570\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_11_mtheme_image\" class=\"input-full input-upload\" value=\"http://placehold.it/406x406/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_11][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></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_11_mtheme_description\">Staff Description</label>
							<span class=\"description_text\">
								Staff Description
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_11_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_11_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_11][mtheme_description]\" id=\"aq_block_11_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div>			
				<ul id=\"aq-sortable-list-aq_block_11\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_11\">
								<li id=\"aq_block_11_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Facebook						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_11_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_11_tabs-1-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_11][tabs][1][social_icon]\" value=\"fa fa-facebook\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-facebook\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_11_tabs-1-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_11_tabs-1-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_11][tabs][1][social_text]\" value=\"Facebook\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_11_tabs-1-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_11_tabs-1-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_11][tabs][1][social_link]\" value=\"http://www.facebook.com/\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_11_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Twitter						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_11_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_11_tabs-2-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_11][tabs][2][social_icon]\" value=\"fa fa-twitter\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-twitter\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_11_tabs-2-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_11_tabs-2-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_11][tabs][2][social_text]\" value=\"Twitter\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_11_tabs-2-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_11_tabs-2-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_11][tabs][2][social_link]\" value=\"http://www.twitter.com/\" type=\"text\"></span></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"staff\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_11][id_base]\" value=\"em_staff\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_11][name]\" value=\"Staff\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_11][order]\" value=\"6\" 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=\"2\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-12\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Staff Blocks\"><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_staff\" 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=\"color:#2E99E6;\"><i class=\"fa fa-user\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</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\">Staff</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_12][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-12\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_12_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_12_mtheme_animated\" name=\"aq_blocks[aq_block_12][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_12_mtheme_title\">Staff title</label>
							<span class=\"description_text\">
								Staff title
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_12_mtheme_title\" class=\"input-text-full\" value=\"Production Deisgner\" name=\"aq_blocks[aq_block_12][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_12_mtheme_name\">Staff name</label>
							<span class=\"description_text\">
								Staff name
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_12_mtheme_name\" class=\"input-text-full\" value=\"John Doe\" name=\"aq_blocks[aq_block_12][mtheme_name]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_12_mtheme_image\">Staff image</label>
							<span class=\"description_text\">
								Staff image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_12_mtheme_image_imageid\" name=\"aq_blocks[aq_block_12][mtheme_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_12_mtheme_image\" class=\"input-full input-upload\" value=\"\" name=\"aq_blocks[aq_block_12][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></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_12_mtheme_description\">Staff Description</label>
							<span class=\"description_text\">
								Staff Description
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_12_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_12_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_12][mtheme_description]\" id=\"aq_block_12_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div>			
				<ul id=\"aq-sortable-list-aq_block_12\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_12\">
								<li id=\"aq_block_12_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Facebook						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_12_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_12_tabs-1-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_12][tabs][1][social_icon]\" value=\"fa fa-facebook\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-facebook\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_12_tabs-1-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_12_tabs-1-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_12][tabs][1][social_text]\" value=\"Facebook\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_12_tabs-1-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_12_tabs-1-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_12][tabs][1][social_link]\" value=\"http://www.facebook.com/\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_12_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Twitter						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_12_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_12_tabs-2-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_12][tabs][2][social_icon]\" value=\"fa fa-twitter\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-twitter\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_12_tabs-2-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_12_tabs-2-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_12][tabs][2][social_text]\" value=\"Twitter\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_12_tabs-2-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_12_tabs-2-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_12][tabs][2][social_link]\" value=\"http://www.twitter.com/\" type=\"text\"></span></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"staff\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_12][id_base]\" value=\"em_staff\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_12][name]\" value=\"Staff\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_12][order]\" value=\"7\" 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=\"2\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-13\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Staff Blocks\"><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_staff\" 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=\"color:#2E99E6;\"><i class=\"fa fa-user\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</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\">Staff</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_13][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-13\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_13_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_13_mtheme_animated\" name=\"aq_blocks[aq_block_13][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_13_mtheme_title\">Staff title</label>
							<span class=\"description_text\">
								Staff title
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_13_mtheme_title\" class=\"input-text-full\" value=\"Production Deisgner\" name=\"aq_blocks[aq_block_13][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_13_mtheme_name\">Staff name</label>
							<span class=\"description_text\">
								Staff name
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_13_mtheme_name\" class=\"input-text-full\" value=\"John Doe\" name=\"aq_blocks[aq_block_13][mtheme_name]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_13_mtheme_image\">Staff image</label>
							<span class=\"description_text\">
								Staff image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_13_mtheme_image_imageid\" name=\"aq_blocks[aq_block_13][mtheme_imageid]\" value=\"7572\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_13_mtheme_image\" class=\"input-full input-upload\" value=\"http://placehold.it/406x406/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_13][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></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_13_mtheme_description\">Staff Description</label>
							<span class=\"description_text\">
								Staff Description
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_13_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_13_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_13][mtheme_description]\" id=\"aq_block_13_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div>			
				<ul id=\"aq-sortable-list-aq_block_13\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_13\">
								<li id=\"aq_block_13_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Facebook						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_13_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_13_tabs-1-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_13][tabs][1][social_icon]\" value=\"fa fa-facebook\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-facebook\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_13_tabs-1-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_13_tabs-1-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_13][tabs][1][social_text]\" value=\"Facebook\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_13_tabs-1-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_13_tabs-1-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_13][tabs][1][social_link]\" value=\"http://www.facebook.com/\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_13_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Twitter						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_13_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_13_tabs-2-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_13][tabs][2][social_icon]\" value=\"fa fa-twitter\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-twitter\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_13_tabs-2-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_13_tabs-2-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_13][tabs][2][social_text]\" value=\"Twitter\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_13_tabs-2-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_13_tabs-2-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_13][tabs][2][social_link]\" value=\"http://www.twitter.com/\" type=\"text\"></span></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"staff\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_13][id_base]\" value=\"em_staff\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_13][name]\" value=\"Staff\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_13][order]\" value=\"8\" 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=\"2\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-14\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Staff Blocks\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-14\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"14\" data-mblocktype=\"em_staff\" 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=\"color:#2E99E6;\"><i class=\"fa fa-user\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-14\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Staff</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_14][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-14\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_14_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_14_mtheme_animated\" name=\"aq_blocks[aq_block_14][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></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_14_mtheme_title\">Staff title</label>
							<span class=\"description_text\">
								Staff title
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_14_mtheme_title\" class=\"input-text-full\" value=\"Production Deisgner\" name=\"aq_blocks[aq_block_14][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_14_mtheme_name\">Staff name</label>
							<span class=\"description_text\">
								Staff name
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_14_mtheme_name\" class=\"input-text-full\" value=\"John Doe\" name=\"aq_blocks[aq_block_14][mtheme_name]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_14_mtheme_image\">Staff image</label>
							<span class=\"description_text\">
								Staff image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_14_mtheme_image_imageid\" name=\"aq_blocks[aq_block_14][mtheme_imageid]\" value=\"7573\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_14_mtheme_image\" class=\"input-full input-upload\" value=\"http://placehold.it/406x406/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_14][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></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_14_mtheme_description\">Staff Description</label>
							<span class=\"description_text\">
								Staff Description
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_14_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_14_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_14][mtheme_description]\" id=\"aq_block_14_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div>			
				<ul id=\"aq-sortable-list-aq_block_14\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_14\">
								<li id=\"aq_block_14_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Facebook						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_14_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_14_tabs-1-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_14][tabs][1][social_icon]\" value=\"fa fa-facebook\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-facebook\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_14_tabs-1-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_14_tabs-1-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_14][tabs][1][social_text]\" value=\"Facebook\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_14_tabs-1-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_14_tabs-1-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_14][tabs][1][social_link]\" value=\"http://www.facebook.com/\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_14_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Twitter						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_14_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</span>
						<span class=\"rightHalf\"></span></p><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_14_tabs-2-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_14][tabs][2][social_icon]\" value=\"fa fa-twitter\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-twitter\"></i></div><p></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_14_tabs-2-social_text\">Social Text</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_14_tabs-2-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_14][tabs][2][social_text]\" value=\"Twitter\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_14_tabs-2-social_link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_14_tabs-2-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_14][tabs][2][social_link]\" value=\"http://www.twitter.com/\" type=\"text\"></span></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"staff\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_14][id_base]\" value=\"em_staff\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_14][name]\" value=\"Staff\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_14][order]\" value=\"9\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_14][size]\" value=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_14][parent]\" value=\"2\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_14][number]\" value=\"14\" type=\"hidden\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li></ul><div id=\"my-column-content-5\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
						  <h4 class=\"modal-title\">Column Container</h4>
						  <label for=\"blockID\">Block ID</label><input class=\"blockID\" name=\"aq_blocks[aq_block_5][blockID]\" value=\"\" id=\"blockID\" type=\"text\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_container_type\">Boxed or Fullwidth</label>
							<span class=\"description_text\">
								Boxed or Fullwidth. For full columns
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_5_container_type\" name=\"aq_blocks[aq_block_5][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_text_intensity\">Text Intensity</label>
							<span class=\"description_text\">
								Text Intensity for headings types
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_5_text_intensity\" name=\"aq_blocks[aq_block_5][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_margin_top\">Margin top in pixels</label>
							<span class=\"description_text\">
								Margin top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_5_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_5][margin_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"description_text\">
								Margin bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_5_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_5][margin_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_padding_top\">Padding top in pixels</label>
							<span class=\"description_text\">
								Padding top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_5_padding_top\" class=\"input-text-full\" value=\"0\" name=\"aq_blocks[aq_block_5][padding_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"description_text\">
								Padding bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_5_padding_bottom\" class=\"input-text-full\" value=\"80\" name=\"aq_blocks[aq_block_5][padding_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_padding_sides\">Padding sides in pixels</label>
							<span class=\"description_text\">
								Padding sides in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_5_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_5][padding_sides]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_background_color\">Background color</label>
							<span class=\"description_text\">
								Background color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_5_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_5][background_color]\" data-default-color=\"\" type=\"text\"><input value=\"Clear\" class=\"button button-small hidden wp-picker-clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 0px; top: 182.133px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , 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));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 0%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_background_image\">Background Image</label>
							<span class=\"description_text\">
								Background Image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_5_background_image_imageid\" name=\"aq_blocks[aq_block_5][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_5_background_image\" class=\"input-full input-upload\" value=\"\" name=\"aq_blocks[aq_block_5][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></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_5_background_scroll\">Scroll effect</label>
							<span class=\"description_text\">
								Scroll effect
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_5_background_scroll\" name=\"aq_blocks[aq_block_5][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</option></select></span></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_5][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_5][name]\" value=\"Fullwidth Container\" 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=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_5][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_5][number]\" value=\"5\" type=\"hidden\">				</div>
			<div style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li>
		<li style=\"top: auto; left: 0px;\" id=\"template-block-15\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\"><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-15\" 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:#2E99E6;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-15\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li style=\"top: auto; left: 0px;\" id=\"template-block-16\" class=\"block block-em_photocard span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Photocard\"><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_photocard\" 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=\"color:#2E99E6;\"><i class=\"fa fa-camera\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Photocard</div><div class=\"block-size\">12/12</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\">Photocard</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_16][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-16\">
						<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_16_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_16_mtheme_animated\" name=\"aq_blocks[aq_block_16][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\" selected=\"selected\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_16_mtheme_background_color\">Background color</label>
							<span class=\"description_text\">
								Background color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" style=\"background-color: rgb(249, 249, 249);\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_16_mtheme_background_color\" class=\"input-color-picker wp-color-picker\" value=\"#f9f9f9\" name=\"aq_blocks[aq_block_16][mtheme_background_color]\" data-default-color=\"\" type=\"text\"><input value=\"Clear\" class=\"button button-small hidden wp-picker-clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 0px; top: 3.64266px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , 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));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(249, 0, 0), rgb(249, 249, 249));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 0%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_16_mtheme_image_block\">Image block display</label>
							<span class=\"description_text\">
								Image block display
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_16_mtheme_image_block\" name=\"aq_blocks[aq_block_16][mtheme_image_block]\"><option value=\"left\" selected=\"selected\">Left</option><option value=\"right\">Right</option></select></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_16_mtheme_image\">Add image</label>
							<span class=\"description_text\">
								Upload image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_16_mtheme_image_imageid\" name=\"aq_blocks[aq_block_16][mtheme_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_16_mtheme_image\" class=\"input-full input-upload\" value=\"http://placehold.it/1400x780/ffcc00/ffffff/\" name=\"aq_blocks[aq_block_16][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></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_16_mtheme_video_mp4\">MP4</label>
							<span class=\"description_text\">
								MP4 url.
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_16_mtheme_video_mp4\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_16][mtheme_video_mp4]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_16_mtheme_video_webm\">WEBM</label>
							<span class=\"description_text\">
								WEBM url
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_16_mtheme_video_webm\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_16][mtheme_video_webm]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_16_mtheme_video_ogv\">OGV</label>
							<span class=\"description_text\">
								OGV url
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_16_mtheme_video_ogv\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_16][mtheme_video_ogv]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_16_mtheme_content_color\">Content Color</label>
							<span class=\"description_text\">
								Content Color
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_16_mtheme_content_color\" name=\"aq_blocks[aq_block_16][mtheme_content_color]\"><option value=\"default\">Default</option><option value=\"dark\" selected=\"selected\">Dark</option><option value=\"bright\">Bright</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_16_mtheme_text_align\">Text align</label>
							<span class=\"description_text\">
								Text align
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_16_mtheme_text_align\" name=\"aq_blocks[aq_block_16][mtheme_text_align]\"><option value=\"center\">center</option><option value=\"left\" selected=\"selected\">left</option><option value=\"right\">right</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_16_mtheme_title\">Title Text</label>
							<span class=\"description_text\">
								Title Text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_16_mtheme_title\" class=\"input-text-full\" value=\"Presentations\" name=\"aq_blocks[aq_block_16][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_16_mtheme_subtitle\">Subtitle text</label>
							<span class=\"description_text\">
								Subtitle text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_16_mtheme_subtitle\" class=\"input-text-full\" value=\"Glaciers of Mounts\" name=\"aq_blocks[aq_block_16][mtheme_subtitle]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_16_mtheme_button\">Button Text</label>
							<span class=\"description_text\">
								Button Text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_16_mtheme_button\" class=\"input-text-full\" value=\"Experience\" name=\"aq_blocks[aq_block_16][mtheme_button]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_16_mtheme_button_link\">Button link</label>
							<span class=\"description_text\">
								Button link
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_16_mtheme_button_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_16][mtheme_button_link]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_16_mtheme_content_richtext\">Text for contents</label>
							<span class=\"description_text\">
								Text for contents
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_16_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_16_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_16][mtheme_content_richtext]\" id=\"aq_block_16_mtheme_content_richtext\">&lt;p&gt;In egestas lacus turpis, et pretium nibh imperdiet id. Quisque lacinia consequat ante tempus posuere. Nullam sollicitudin neque at rutrum pellentesque. Nullam ac sapien a dui molestie dapibus. Integer erat neque, ullamcorper id turpis a, hendrerit ultricies mauris. Aenean sollicitudin efficitur lacus, at ultrices dolor finibus eu.&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>

</span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_16][id_base]\" value=\"em_photocard\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_16][name]\" value=\"Photocard\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_16][order]\" value=\"1\" 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=\"3\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li></ul><div id=\"my-column-content-15\" 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\">Block ID</label><input class=\"blockID\" name=\"aq_blocks[aq_block_15][blockID]\" value=\"\" id=\"blockID\" type=\"text\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_15_container_type\">Boxed or Fullwidth</label>
							<span class=\"description_text\">
								Boxed or Fullwidth. For full columns
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_15_container_type\" name=\"aq_blocks[aq_block_15][container_type]\"><option value=\"boxed\">Boxed</option><option value=\"fullwidth\" selected=\"selected\">Fullwidth</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_15_text_intensity\">Text Intensity</label>
							<span class=\"description_text\">
								Text Intensity for headings types
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_15_text_intensity\" name=\"aq_blocks[aq_block_15][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_15_margin_top\">Margin top in pixels</label>
							<span class=\"description_text\">
								Margin top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_15_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_15][margin_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_15_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"description_text\">
								Margin bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_15_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_15][margin_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_15_padding_top\">Padding top in pixels</label>
							<span class=\"description_text\">
								Padding top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_15_padding_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_15][padding_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_15_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"description_text\">
								Padding bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_15_padding_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_15][padding_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_15_padding_sides\">Padding sides in pixels</label>
							<span class=\"description_text\">
								Padding sides in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_15_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_15][padding_sides]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_15_background_color\">Background color</label>
							<span class=\"description_text\">
								Background color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_15_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_15][background_color]\" data-default-color=\"\" type=\"text\"><input value=\"Clear\" class=\"button button-small hidden wp-picker-clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 0px; top: 182.133px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , 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));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 0%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_15_background_image\">Background Image</label>
							<span class=\"description_text\">
								Background Image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_15_background_image_imageid\" name=\"aq_blocks[aq_block_15][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_15_background_image\" class=\"input-full input-upload\" value=\"\" name=\"aq_blocks[aq_block_15][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></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_15_background_scroll\">Scroll effect</label>
							<span class=\"description_text\">
								Scroll effect
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_15_background_scroll\" name=\"aq_blocks[aq_block_15][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</option></select></span></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_15][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_15][name]\" value=\"Fullwidth Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_15][order]\" value=\"3\" 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=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_15][number]\" value=\"15\" type=\"hidden\">				</div>
			<div style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li>
		<li style=\"top: auto; left: 0px;\" id=\"template-block-17\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\"><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:#2E99E6;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</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 style=\"top: auto; left: 0px;\" id=\"template-block-18\" class=\"block block-em_fromtocounter span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add From to Counter\"><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_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=\"color:#2E99E6;\"><i class=\"fa fa-circle-o-notch\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">From-To Counter</div><div class=\"block-size\">3/12</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\">From-To Counter</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_18][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-18\">
						<div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_18_mtheme_title\">Title</label>
							<span class=\"description_text\">
								Title
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_18_mtheme_title\" class=\"input-text-full\" value=\"Projects\" name=\"aq_blocks[aq_block_18][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_18_mtheme_description\">Description</label>
							<span class=\"description_text\">
								Description
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_18_mtheme_description\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_18][mtheme_description]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_18_mtheme_to\">Count to</label>
							<span class=\"description_text\">
								Count to
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_18_mtheme_to\" class=\"input-text-full\" value=\"1205\" name=\"aq_blocks[aq_block_18][mtheme_to]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><span class=\"leftHalf\">
							<label for=\"aq_block_18_mtheme_icon\">Select Icon</label>
							<span class=\"description_text\">
								Click an icon to select, click again to deselect
							</span>
						</span><span class=\"rightHalf fontawesome-iconpicker\"><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_18_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_18][mtheme_icon]\" value=\"et-icon-telescope\" type=\"hidden\"><i class=\"fontawesome_icon preview et-icon-telescope\"></i></div></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_18_mtheme_iconcolor\">Icon Color</label>
							<span class=\"description_text\">
								Leave blank for default
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" style=\"background-color: rgb(254, 70, 65);\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_18_mtheme_iconcolor\" class=\"input-color-picker wp-color-picker\" value=\"#fe4641\" name=\"aq_blocks[aq_block_18][mtheme_iconcolor]\" data-default-color=\"\" type=\"text\"><input value=\"Clear\" class=\"button button-small hidden wp-picker-clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 1.01185px; top: 0px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , rgb(255, 66, 66), rgb(255, 160, 66), rgb(255, 255, 66), rgb(160, 255, 66), rgb(66, 255, 66), rgb(66, 255, 160), rgb(66, 255, 254), rgb(66, 160, 255), rgb(66, 66, 255), rgb(160, 66, 255), rgb(254, 66, 255), rgb(255, 66, 160), rgb(255, 66, 66));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(255, 8, 0), rgb(255, 255, 255));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 74%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_18][id_base]\" value=\"em_fromtocounter\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_18][name]\" value=\"From-To Counter\" 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=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_18][parent]\" value=\"4\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-19\" class=\"block block-em_fromtocounter span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add From to Counter\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-19\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"19\" data-mblocktype=\"em_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=\"color:#2E99E6;\"><i class=\"fa fa-circle-o-notch\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">From-To Counter</div><div class=\"block-size\">3/12</div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-19\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">From-To Counter</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_19][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-19\">
						<div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_19_mtheme_title\">Title</label>
							<span class=\"description_text\">
								Title
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_19_mtheme_title\" class=\"input-text-full\" value=\"Diversity\" name=\"aq_blocks[aq_block_19][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_19_mtheme_description\">Description</label>
							<span class=\"description_text\">
								Description
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_19_mtheme_description\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_19][mtheme_description]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_19_mtheme_to\">Count to</label>
							<span class=\"description_text\">
								Count to
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_19_mtheme_to\" class=\"input-text-full\" value=\"874\" name=\"aq_blocks[aq_block_19][mtheme_to]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><span class=\"leftHalf\">
							<label for=\"aq_block_19_mtheme_icon\">Select Icon</label>
							<span class=\"description_text\">
								Click an icon to select, click again to deselect
							</span>
						</span><span class=\"rightHalf fontawesome-iconpicker\"><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_19_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_19][mtheme_icon]\" value=\"et-icon-circle-compass\" type=\"hidden\"><i class=\"fontawesome_icon preview et-icon-circle-compass\"></i></div></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_19_mtheme_iconcolor\">Icon Color</label>
							<span class=\"description_text\">
								Leave blank for default
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" style=\"background-color: rgb(254, 70, 65);\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_19_mtheme_iconcolor\" class=\"input-color-picker wp-color-picker\" value=\"#fe4641\" name=\"aq_blocks[aq_block_19][mtheme_iconcolor]\" data-default-color=\"\" type=\"text\"><input value=\"Clear\" class=\"button button-small hidden wp-picker-clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 1.01185px; top: 0px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , rgb(255, 66, 66), rgb(255, 160, 66), rgb(255, 255, 66), rgb(160, 255, 66), rgb(66, 255, 66), rgb(66, 255, 160), rgb(66, 255, 254), rgb(66, 160, 255), rgb(66, 66, 255), rgb(160, 66, 255), rgb(254, 66, 255), rgb(255, 66, 160), rgb(255, 66, 66));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(255, 8, 0), rgb(255, 255, 255));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 74%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_19][id_base]\" value=\"em_fromtocounter\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_19][name]\" value=\"From-To Counter\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_19][order]\" value=\"2\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_19][size]\" value=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_19][parent]\" value=\"4\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_19][number]\" value=\"19\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-20\" class=\"block block-em_fromtocounter span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add From to Counter\"><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_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=\"color:#2E99E6;\"><i class=\"fa fa-circle-o-notch\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">From-To Counter</div><div class=\"block-size\">3/12</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\">From-To Counter</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_20][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-20\">
						<div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_20_mtheme_title\">Title</label>
							<span class=\"description_text\">
								Title
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_20_mtheme_title\" class=\"input-text-full\" value=\"Associates\" name=\"aq_blocks[aq_block_20][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_20_mtheme_description\">Description</label>
							<span class=\"description_text\">
								Description
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_20_mtheme_description\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_20][mtheme_description]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_20_mtheme_to\">Count to</label>
							<span class=\"description_text\">
								Count to
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_20_mtheme_to\" class=\"input-text-full\" value=\"1054\" name=\"aq_blocks[aq_block_20][mtheme_to]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><span class=\"leftHalf\">
							<label for=\"aq_block_20_mtheme_icon\">Select Icon</label>
							<span class=\"description_text\">
								Click an icon to select, click again to deselect
							</span>
						</span><span class=\"rightHalf fontawesome-iconpicker\"><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_20_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_20][mtheme_icon]\" value=\"et-icon-linegraph\" type=\"hidden\"><i class=\"fontawesome_icon preview et-icon-linegraph\"></i></div></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_20_mtheme_iconcolor\">Icon Color</label>
							<span class=\"description_text\">
								Leave blank for default
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" style=\"background-color: rgb(254, 70, 65);\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_20_mtheme_iconcolor\" class=\"input-color-picker wp-color-picker\" value=\"#fe4641\" name=\"aq_blocks[aq_block_20][mtheme_iconcolor]\" data-default-color=\"\" type=\"text\"><input value=\"Clear\" class=\"button button-small hidden wp-picker-clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 1.01185px; top: 0px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , rgb(255, 66, 66), rgb(255, 160, 66), rgb(255, 255, 66), rgb(160, 255, 66), rgb(66, 255, 66), rgb(66, 255, 160), rgb(66, 255, 254), rgb(66, 160, 255), rgb(66, 66, 255), rgb(160, 66, 255), rgb(254, 66, 255), rgb(255, 66, 160), rgb(255, 66, 66));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(255, 8, 0), rgb(255, 255, 255));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 74%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_20][id_base]\" value=\"em_fromtocounter\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_20][name]\" value=\"From-To Counter\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_20][order]\" value=\"3\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_20][size]\" value=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_20][parent]\" value=\"4\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-21\" class=\"block block-em_fromtocounter span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add From to Counter\"><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_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=\"color:#2E99E6;\"><i class=\"fa fa-circle-o-notch\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">From-To Counter</div><div class=\"block-size\">3/12</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\">From-To Counter</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_21][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-21\">
						<div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_21_mtheme_title\">Title</label>
							<span class=\"description_text\">
								Title
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_21_mtheme_title\" class=\"input-text-full\" value=\"Locations\" name=\"aq_blocks[aq_block_21][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_21_mtheme_description\">Description</label>
							<span class=\"description_text\">
								Description
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_21_mtheme_description\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_21][mtheme_description]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_21_mtheme_to\">Count to</label>
							<span class=\"description_text\">
								Count to
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_21_mtheme_to\" class=\"input-text-full\" value=\"1043\" name=\"aq_blocks[aq_block_21][mtheme_to]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><span class=\"leftHalf\">
							<label for=\"aq_block_21_mtheme_icon\">Select Icon</label>
							<span class=\"description_text\">
								Click an icon to select, click again to deselect
							</span>
						</span><span class=\"rightHalf fontawesome-iconpicker\"><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_21_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_21][mtheme_icon]\" value=\"et-icon-map\" type=\"hidden\"><i class=\"fontawesome_icon preview et-icon-map\"></i></div></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_21_mtheme_iconcolor\">Icon Color</label>
							<span class=\"description_text\">
								Leave blank for default
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" style=\"background-color: rgb(254, 70, 65);\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_21_mtheme_iconcolor\" class=\"input-color-picker wp-color-picker\" value=\"#fe4641\" name=\"aq_blocks[aq_block_21][mtheme_iconcolor]\" data-default-color=\"\" type=\"text\"><input value=\"Clear\" class=\"button button-small hidden wp-picker-clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 1.01185px; top: 0px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , rgb(255, 66, 66), rgb(255, 160, 66), rgb(255, 255, 66), rgb(160, 255, 66), rgb(66, 255, 66), rgb(66, 255, 160), rgb(66, 255, 254), rgb(66, 160, 255), rgb(66, 66, 255), rgb(160, 66, 255), rgb(254, 66, 255), rgb(255, 66, 160), rgb(255, 66, 66));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(255, 8, 0), rgb(255, 255, 255));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 74%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_21][id_base]\" value=\"em_fromtocounter\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_21][name]\" value=\"From-To Counter\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_21][order]\" value=\"4\" 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=\"4\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></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\">Block ID</label><input class=\"blockID\" name=\"aq_blocks[aq_block_17][blockID]\" value=\"\" id=\"blockID\" type=\"text\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_17_container_type\">Boxed or Fullwidth</label>
							<span class=\"description_text\">
								Boxed or Fullwidth. For full columns
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_17_container_type\" name=\"aq_blocks[aq_block_17][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_17_text_intensity\">Text Intensity</label>
							<span class=\"description_text\">
								Text Intensity for headings types
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_17_text_intensity\" name=\"aq_blocks[aq_block_17][text_intensity]\"><option value=\"default\">Default</option><option value=\"dark\" selected=\"selected\">Dark</option><option value=\"bright\">Bright</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_17_margin_top\">Margin top in pixels</label>
							<span class=\"description_text\">
								Margin top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_17_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_17][margin_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_17_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"description_text\">
								Margin bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_17_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_17][margin_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_17_padding_top\">Padding top in pixels</label>
							<span class=\"description_text\">
								Padding top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_17_padding_top\" class=\"input-text-full\" value=\"140\" name=\"aq_blocks[aq_block_17][padding_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_17_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"description_text\">
								Padding bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_17_padding_bottom\" class=\"input-text-full\" value=\"100\" name=\"aq_blocks[aq_block_17][padding_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_17_padding_sides\">Padding sides in pixels</label>
							<span class=\"description_text\">
								Padding sides in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_17_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_17][padding_sides]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_17_background_color\">Background color</label>
							<span class=\"description_text\">
								Background color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" style=\"background-color: rgb(0, 0, 0);\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_17_background_color\" class=\"input-color-picker wp-color-picker\" value=\"#000000\" name=\"aq_blocks[aq_block_17][background_color]\" data-default-color=\"\" type=\"text\"><input value=\"Clear\" class=\"button button-small hidden wp-picker-clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 0px; top: 182.133px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , 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));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 0%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_17_background_image\">Background Image</label>
							<span class=\"description_text\">
								Background Image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_17_background_image_imageid\" name=\"aq_blocks[aq_block_17][background_imageid]\" value=\"7558\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_17_background_image\" class=\"input-full input-upload\" value=\"http://placehold.it/1400x780/2B99FC/ffffff/\" 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></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_17_background_scroll\">Scroll effect</label>
							<span class=\"description_text\">
								Scroll effect
							</span>
						</span><span class=\"rightHalf 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></span></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=\"Fullwidth Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_17][order]\" value=\"4\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li>
		<li style=\"top: auto; left: 0px;\" id=\"template-block-22\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\"><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-22\" 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:#2E99E6;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-22\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li style=\"top: auto; left: 0px;\" id=\"template-block-23\" class=\"block block-em_photocard span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Photocard\"><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_photocard\" 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=\"color:#2E99E6;\"><i class=\"fa fa-camera\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Photocard</div><div class=\"block-size\">12/12</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\">Photocard</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_23][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-23\">
						<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_23_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_23_mtheme_animated\" name=\"aq_blocks[aq_block_23][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\" selected=\"selected\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_23_mtheme_background_color\">Background color</label>
							<span class=\"description_text\">
								Background color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" style=\"background-color: rgb(94, 94, 94);\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_23_mtheme_background_color\" class=\"input-color-picker wp-color-picker\" value=\"#5e5e5e\" name=\"aq_blocks[aq_block_23][mtheme_background_color]\" data-default-color=\"\" type=\"text\"><input value=\"Clear\" class=\"button button-small hidden wp-picker-clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 0px; top: 114.744px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , 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));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(91, 0, 0), rgb(94, 94, 94));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 0%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_23_mtheme_image_block\">Image block display</label>
							<span class=\"description_text\">
								Image block display
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_23_mtheme_image_block\" name=\"aq_blocks[aq_block_23][mtheme_image_block]\"><option value=\"left\">Left</option><option value=\"right\" selected=\"selected\">Right</option></select></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_23_mtheme_image\">Add image</label>
							<span class=\"description_text\">
								Upload image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_23_mtheme_image_imageid\" name=\"aq_blocks[aq_block_23][mtheme_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_23_mtheme_image\" class=\"input-full input-upload\" value=\"http://placehold.it/1400x780/ffcc00/ffffff/\" name=\"aq_blocks[aq_block_23][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></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_23_mtheme_video_mp4\">MP4</label>
							<span class=\"description_text\">
								MP4 url.
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_23_mtheme_video_mp4\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_23][mtheme_video_mp4]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_23_mtheme_video_webm\">WEBM</label>
							<span class=\"description_text\">
								WEBM url
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_23_mtheme_video_webm\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_23][mtheme_video_webm]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_23_mtheme_video_ogv\">OGV</label>
							<span class=\"description_text\">
								OGV url
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_23_mtheme_video_ogv\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_23][mtheme_video_ogv]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_23_mtheme_content_color\">Content Color</label>
							<span class=\"description_text\">
								Content Color
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_23_mtheme_content_color\" name=\"aq_blocks[aq_block_23][mtheme_content_color]\"><option value=\"default\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\" selected=\"selected\">Bright</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_23_mtheme_text_align\">Text align</label>
							<span class=\"description_text\">
								Text align
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_23_mtheme_text_align\" name=\"aq_blocks[aq_block_23][mtheme_text_align]\"><option value=\"center\">center</option><option value=\"left\">left</option><option value=\"right\" selected=\"selected\">right</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_23_mtheme_title\">Title Text</label>
							<span class=\"description_text\">
								Title Text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_23_mtheme_title\" class=\"input-text-full\" value=\"Architecture\" name=\"aq_blocks[aq_block_23][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_23_mtheme_subtitle\">Subtitle text</label>
							<span class=\"description_text\">
								Subtitle text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_23_mtheme_subtitle\" class=\"input-text-full\" value=\"Interior Design\" name=\"aq_blocks[aq_block_23][mtheme_subtitle]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_23_mtheme_button\">Button Text</label>
							<span class=\"description_text\">
								Button Text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_23_mtheme_button\" class=\"input-text-full\" value=\"Experience\" name=\"aq_blocks[aq_block_23][mtheme_button]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_23_mtheme_button_link\">Button link</label>
							<span class=\"description_text\">
								Button link
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_23_mtheme_button_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_23][mtheme_button_link]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_23_mtheme_content_richtext\">Text for contents</label>
							<span class=\"description_text\">
								Text for contents
							</span>
						</span><span class=\"rightHalf 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;In egestas lacus turpis, et pretium nibh imperdiet id. Quisque lacinia consequat ante tempus posuere. Nullam sollicitudin neque at rutrum pellentesque. Nullam ac sapien a dui molestie dapibus. Integer erat neque, ullamcorper id turpis a, hendrerit ultricies mauris. Aenean sollicitudin efficitur lacus, at ultrices dolor finibus eu.&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>

</span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_23][id_base]\" value=\"em_photocard\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_23][name]\" value=\"Photocard\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_23][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_23][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_23][parent]\" value=\"5\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li></ul><div id=\"my-column-content-22\" 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\">Block ID</label><input class=\"blockID\" name=\"aq_blocks[aq_block_22][blockID]\" value=\"\" id=\"blockID\" type=\"text\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_22_container_type\">Boxed or Fullwidth</label>
							<span class=\"description_text\">
								Boxed or Fullwidth. For full columns
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_22_container_type\" name=\"aq_blocks[aq_block_22][container_type]\"><option value=\"boxed\">Boxed</option><option value=\"fullwidth\" selected=\"selected\">Fullwidth</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_22_text_intensity\">Text Intensity</label>
							<span class=\"description_text\">
								Text Intensity for headings types
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_22_text_intensity\" name=\"aq_blocks[aq_block_22][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_22_margin_top\">Margin top in pixels</label>
							<span class=\"description_text\">
								Margin top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_22_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_22][margin_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_22_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"description_text\">
								Margin bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_22_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_22][margin_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_22_padding_top\">Padding top in pixels</label>
							<span class=\"description_text\">
								Padding top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_22_padding_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_22][padding_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_22_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"description_text\">
								Padding bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_22_padding_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_22][padding_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_22_padding_sides\">Padding sides in pixels</label>
							<span class=\"description_text\">
								Padding sides in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_22_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_22][padding_sides]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_22_background_color\">Background color</label>
							<span class=\"description_text\">
								Background color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_22_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_22][background_color]\" data-default-color=\"\" type=\"text\"><input value=\"Clear\" class=\"button button-small hidden wp-picker-clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 0px; top: 182.133px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , 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));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 0%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_22_background_image\">Background Image</label>
							<span class=\"description_text\">
								Background Image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_22_background_image_imageid\" name=\"aq_blocks[aq_block_22][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_22_background_image\" class=\"input-full input-upload\" value=\"\" name=\"aq_blocks[aq_block_22][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></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_22_background_scroll\">Scroll effect</label>
							<span class=\"description_text\">
								Scroll effect
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_22_background_scroll\" name=\"aq_blocks[aq_block_22][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</option></select></span></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_22][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_22][name]\" value=\"Fullwidth Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_22][order]\" value=\"5\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_22][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_22][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_22][number]\" value=\"22\" type=\"hidden\">				</div>
			<div style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li>
		<li style=\"top: auto; left: 0px;\" id=\"template-block-24\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\"><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-24\" 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:#2E99E6;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-24\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li style=\"top: auto; left: 0px;\" id=\"template-block-25\" class=\"block block-em_sectionheading span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Section Heading\"><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-25\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"25\" 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=\"color:#2E99E6;\"><i class=\"fa fa-header\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Section Heading</div><div class=\"block-size\">12/12</div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-25\">						  <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>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_25][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-25\">
						<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_25_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_25_mtheme_animated\" name=\"aq_blocks[aq_block_25][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_25_mtheme_title\">Section Heading text</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_25_mtheme_title\" class=\"input-text-full\" value=\"Aims and Objectives\" name=\"aq_blocks[aq_block_25][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_25_mtheme_subtitle\">Section subtitle (optional)</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_25_mtheme_subtitle\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_25][mtheme_subtitle]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_25_mtheme_align\">Align text</label>
							<span class=\"description_text\">
								Align text
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_25_mtheme_align\" name=\"aq_blocks[aq_block_25][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_25_mtheme_size\">Heading size</label>
							<span class=\"description_text\">
								Heading size
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_25_mtheme_size\" name=\"aq_blocks[aq_block_25][mtheme_size]\"><option value=\"1\">h1</option><option value=\"2\" selected=\"selected\">h2</option><option value=\"3\">h3</option><option value=\"4\">h4</option><option value=\"5\">h5</option><option value=\"6\">h6</option></select></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_25_mtheme_content_richtext\">Content</label>
							<span class=\"description_text\">
								Add content
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_25_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_25_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_25][mtheme_content_richtext]\" id=\"aq_block_25_mtheme_content_richtext\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_25_mtheme_button\">Button Text</label>
							<span class=\"description_text\">
								Button Text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_25_mtheme_button\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_25][mtheme_button]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_25_mtheme_button_link\">Button link</label>
							<span class=\"description_text\">
								Button link
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_25_mtheme_button_link\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_25][mtheme_button_link]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_25_mtheme_width\">Width in percent</label>
							<span class=\"description_text\">
								Width in percent
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_25_mtheme_width\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_25][mtheme_width]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_25_mtheme_top\">Padding Top in pixels</label>
							<span class=\"description_text\">
								Top Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_25_mtheme_top\" class=\"input-text-full\" value=\"100\" name=\"aq_blocks[aq_block_25][mtheme_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_25_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"description_text\">
								Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_25_mtheme_bottom\" class=\"input-text-full\" value=\"30\" name=\"aq_blocks[aq_block_25][mtheme_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_25_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"description_text\">
								Margin Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_25_mtheme_marginbottom\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_25][mtheme_marginbottom]\" type=\"text\"></span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_25][id_base]\" value=\"em_sectionheading\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_25][name]\" value=\"Section Heading\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_25][order]\" value=\"1\" 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=\"6\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_25][number]\" value=\"25\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-26\" class=\"block block-em_displayrichtext span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Richtext\"><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_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=\"color:#2E99E6;\"><i class=\"fa fa-text-height\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Richtext Box</div><div class=\"block-size\">6/12</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\">Richtext Box</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_26][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-26\">
						<div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_26_mtheme_content_richtext\">Rich Text</label>
							<span class=\"description_text\">
								Add the content
							</span>
						</span><span class=\"rightHalf 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;h3&gt;Mission&lt;/h3&gt;
&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;br /&gt;&lt;br /&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>

</span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_26][id_base]\" value=\"em_displayrichtext\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_26][name]\" value=\"Richtext Box\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_26][order]\" value=\"2\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_26][size]\" value=\"span6\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_26][parent]\" value=\"6\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-27\" class=\"block block-em_checklist span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add a Check list\"><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_checklist\" 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=\"color:#2E99E6;\"><i class=\"fa fa-check\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Checklist</div><div class=\"block-size\">6/12</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\">Checklist</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_27][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-27\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><span class=\"leftHalf\">
							<label for=\"aq_block_27_mtheme_icon\">Select icon</label>
							<span class=\"description_text\">
								Select an icon
							</span>
						</span><span class=\"rightHalf fontawesome-iconpicker\"><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_27_mtheme_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_27][mtheme_icon]\" value=\"feather-icon-circle-check\" type=\"hidden\"><i class=\"fontawesome_icon preview feather-icon-circle-check\"></i></div></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_27_mtheme_iconcolor\">Icon color</label>
							<span class=\"description_text\">
								Icon color in hex
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" style=\"background-color: rgb(254, 70, 65);\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_27_mtheme_iconcolor\" class=\"input-color-picker wp-color-picker\" value=\"#fe4641\" name=\"aq_blocks[aq_block_27][mtheme_iconcolor]\" data-default-color=\"#EC3939\" type=\"text\"><input value=\"Default\" class=\"button button-small hidden wp-picker-default\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 1.01185px; top: 0px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , rgb(255, 66, 66), rgb(255, 160, 66), rgb(255, 255, 66), rgb(160, 255, 66), rgb(66, 255, 66), rgb(66, 255, 160), rgb(66, 255, 254), rgb(66, 160, 255), rgb(66, 66, 255), rgb(160, 66, 255), rgb(254, 66, 255), rgb(255, 66, 160), rgb(255, 66, 66));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(255, 8, 0), rgb(255, 255, 255));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 74%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></div>			
				<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>
							Nam at nibh sit amet justo...						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_27_tabs-1-content\">List a line</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_27_tabs-1-content\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][1][content]\" value=\"Nam at nibh sit amet justo dignissim tristique.\" type=\"text\"></span></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>
							Etiam vitae ex elementum,...						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_27_tabs-2-content\">List a line</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_27_tabs-2-content\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][2][content]\" value=\"Etiam vitae ex elementum, aliquet orci quis, efficitur velit.\" type=\"text\"></span></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>
							Curabitur nec ex lacinia,...						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_27_tabs-3-content\">List a line</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_27_tabs-3-content\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][3][content]\" value=\"Curabitur nec ex lacinia, pulvinar libero nec, gravida dui.\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_27_tabs-sortable-item-4\" class=\"sortable-item ui-sortable-handle\" rel=\"4\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Integer iaculis eros sed orci...						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_27_tabs-4-content\">List a line</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_27_tabs-4-content\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][4][content]\" value=\"Integer iaculis eros sed orci ultrices interdum.\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_27_tabs-sortable-item-5\" class=\"sortable-item ui-sortable-handle\" rel=\"5\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Maecenas aliquet enim nec...						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_27_tabs-5-content\">List a line</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_27_tabs-5-content\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][5][content]\" value=\"Maecenas aliquet enim nec justo mattis bibendum.\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_27_tabs-sortable-item-6\" class=\"sortable-item ui-sortable-handle\" rel=\"6\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Aliquam consequat mi nec...						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_27_tabs-6-content\">List a line</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_27_tabs-6-content\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][6][content]\" value=\"Aliquam consequat mi nec faucibus posuere.\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_27_tabs-sortable-item-7\" class=\"sortable-item ui-sortable-handle\" rel=\"7\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Nunc sit amet lectus...						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_27_tabs-7-content\">List a line</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_27_tabs-7-content\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][7][content]\" value=\"Nunc sit amet lectus molestie, volutpat augue ac, tempus lectus.\" type=\"text\"></span></p>			</div>
		</li>
			<li id=\"aq_block_27_tabs-sortable-item-8\" class=\"sortable-item ui-sortable-handle\" rel=\"8\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Integer maximus ante sed...						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_27_tabs-8-content\">List a line</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_27_tabs-8-content\" class=\"input-full\" name=\"aq_blocks[aq_block_27][tabs][8][content]\" value=\"Integer maximus ante sed purus rutrum accumsan.\" type=\"text\"></span></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"checklist\" 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_checklist\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_27][name]\" value=\"Checklist\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_27][order]\" value=\"3\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_27][size]\" value=\"span6\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_27][parent]\" value=\"6\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li></ul><div id=\"my-column-content-24\" 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\">Block ID</label><input class=\"blockID\" name=\"aq_blocks[aq_block_24][blockID]\" value=\"\" id=\"blockID\" type=\"text\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_24_container_type\">Boxed or Fullwidth</label>
							<span class=\"description_text\">
								Boxed or Fullwidth. For full columns
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_24_container_type\" name=\"aq_blocks[aq_block_24][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_24_text_intensity\">Text Intensity</label>
							<span class=\"description_text\">
								Text Intensity for headings types
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_24_text_intensity\" name=\"aq_blocks[aq_block_24][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_24_margin_top\">Margin top in pixels</label>
							<span class=\"description_text\">
								Margin top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_24_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_24][margin_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_24_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"description_text\">
								Margin bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_24_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_24][margin_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_24_padding_top\">Padding top in pixels</label>
							<span class=\"description_text\">
								Padding top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_24_padding_top\" class=\"input-text-full\" value=\"50\" name=\"aq_blocks[aq_block_24][padding_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_24_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"description_text\">
								Padding bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_24_padding_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_24][padding_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_24_padding_sides\">Padding sides in pixels</label>
							<span class=\"description_text\">
								Padding sides in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_24_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_24][padding_sides]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_24_background_color\">Background color</label>
							<span class=\"description_text\">
								Background color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_24_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_24][background_color]\" data-default-color=\"\" type=\"text\"><input value=\"Clear\" class=\"button button-small hidden wp-picker-clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 0px; top: 182.133px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , 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));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 0%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_24_background_image\">Background Image</label>
							<span class=\"description_text\">
								Background Image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_24_background_image_imageid\" name=\"aq_blocks[aq_block_24][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_24_background_image\" class=\"input-full input-upload\" value=\"\" name=\"aq_blocks[aq_block_24][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></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_24_background_scroll\">Scroll effect</label>
							<span class=\"description_text\">
								Scroll effect
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_24_background_scroll\" name=\"aq_blocks[aq_block_24][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</option></select></span></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_24][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_24][name]\" value=\"Fullwidth Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_24][order]\" value=\"6\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_24][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_24][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_24][number]\" value=\"24\" type=\"hidden\">				</div>
			<div style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li>
		<li style=\"top: auto; left: 0px;\" id=\"template-block-28\" class=\"block block-em_dividers span12   ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add a divider\"><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-28\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"28\" data-mblocktype=\"em_dividers\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle ui-sortable-handle\"><div class=\"block-icon\" style=\"color:#2E99E6;\"><i class=\"fa fa-ellipsis-h\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Dividers</div><div class=\"block-size\">12/12</div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-28\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Dividers</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_28][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-28\">
						<div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_28_mtheme_style\">Choose Divider</label>
							<span class=\"description_text\">
								Choose Divider
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_28_mtheme_style\" name=\"aq_blocks[aq_block_28][mtheme_style]\"><option value=\"blank\" selected=\"selected\">blank</option><option value=\"line\">line</option><option value=\"double\">double</option><option value=\"stripes\">stripes</option><option value=\"thinfade\">thinfade</option><option value=\"threelines\">threelines</option><option value=\"circleline\">circleline</option><option value=\"stripedcenter\">stripedcenter</option><option value=\"linedcenter\">linedcenter</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_28_mtheme_top\">Top Space in pixels</label>
							<span class=\"description_text\">
								Top Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_28_mtheme_top\" class=\"input-text-full\" value=\"0\" name=\"aq_blocks[aq_block_28][mtheme_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_28_mtheme_bottom\">Bottom Space pixels</label>
							<span class=\"description_text\">
								Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_28_mtheme_bottom\" class=\"input-text-full\" value=\"50\" name=\"aq_blocks[aq_block_28][mtheme_bottom]\" type=\"text\"></span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_28][id_base]\" value=\"em_dividers\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_28][name]\" value=\"Dividers\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_28][order]\" value=\"7\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_28][size]\" value=\"span12\" 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=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-29\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\"><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-29\" 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:#2E99E6;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-29\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li style=\"top: auto; left: 0px;\" id=\"template-block-30\" class=\"block block-em_sectionheading span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Section Heading\"><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-30\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"30\" 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=\"color:#2E99E6;\"><i class=\"fa fa-header\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Section Heading</div><div class=\"block-size\">12/12</div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-30\">						  <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>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_30][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-30\">
						<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_30_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_30_mtheme_animated\" name=\"aq_blocks[aq_block_30][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_30_mtheme_title\">Section Heading text</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_30_mtheme_title\" class=\"input-text-full\" value=\"Our Clients\" name=\"aq_blocks[aq_block_30][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_30_mtheme_subtitle\">Section subtitle (optional)</label>
							<span class=\"description_text\">
								Section Heading text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_30_mtheme_subtitle\" class=\"input-text-full\" value=\"A diverse client base\" name=\"aq_blocks[aq_block_30][mtheme_subtitle]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_30_mtheme_align\">Align text</label>
							<span class=\"description_text\">
								Align text
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_30_mtheme_align\" name=\"aq_blocks[aq_block_30][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_30_mtheme_size\">Heading size</label>
							<span class=\"description_text\">
								Heading size
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_30_mtheme_size\" name=\"aq_blocks[aq_block_30][mtheme_size]\"><option value=\"1\">h1</option><option value=\"2\" selected=\"selected\">h2</option><option value=\"3\">h3</option><option value=\"4\">h4</option><option value=\"5\">h5</option><option value=\"6\">h6</option></select></span></div><div class=\"description mtheme-input-type-is-editor\"><span class=\"leftHalf\">
							<label for=\"aq_block_30_mtheme_content_richtext\">Content</label>
							<span class=\"description_text\">
								Add content
							</span>
						</span><span class=\"rightHalf editor\"><div id=\"wp-aq_block_30_mtheme_content_richtext-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_30_mtheme_content_richtext-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_30][mtheme_content_richtext]\" id=\"aq_block_30_mtheme_content_richtext\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_30_mtheme_button\">Button Text</label>
							<span class=\"description_text\">
								Button Text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_30_mtheme_button\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_30][mtheme_button]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_30_mtheme_button_link\">Button link</label>
							<span class=\"description_text\">
								Button link
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_30_mtheme_button_link\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_30][mtheme_button_link]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_30_mtheme_width\">Width in percent</label>
							<span class=\"description_text\">
								Width in percent
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_30_mtheme_width\" class=\"input-text-full\" value=\"40\" name=\"aq_blocks[aq_block_30][mtheme_width]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_30_mtheme_top\">Padding Top in pixels</label>
							<span class=\"description_text\">
								Top Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_30_mtheme_top\" class=\"input-text-full\" value=\"100\" name=\"aq_blocks[aq_block_30][mtheme_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_30_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"description_text\">
								Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_30_mtheme_bottom\" class=\"input-text-full\" value=\"30\" name=\"aq_blocks[aq_block_30][mtheme_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_30_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"description_text\">
								Margin Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_30_mtheme_marginbottom\" class=\"input-text-full\" value=\"0\" name=\"aq_blocks[aq_block_30][mtheme_marginbottom]\" type=\"text\"></span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_30][id_base]\" value=\"em_sectionheading\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_30][name]\" value=\"Section Heading\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_30][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_30][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_30][parent]\" value=\"8\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_30][number]\" value=\"30\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-31\" class=\"block block-em_testimonials span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Testimonials\"><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_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=\"color:#2E99E6;\"><i class=\"fa fa-smile-o\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Testimonials</div><div class=\"block-size\">12/12</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\">Testimonials</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_31][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-31\">
									<div class=\"description cf\">
						
				<ul id=\"aq-sortable-list-aq_block_31\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_31\">
								<li id=\"aq_block_31_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Carl Sagan						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_31_tabs-1-name\">Client Name</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_31_tabs-1-name\" class=\"input-full\" name=\"aq_blocks[aq_block_31][tabs][1][name]\" value=\"Carl Sagan\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_31_tabs-1-company\">Company</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_31_tabs-1-company\" class=\"input-full\" name=\"aq_blocks[aq_block_31][tabs][1][company]\" value=\"\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_31_tabs-1-link\">Company link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_31_tabs-1-link\" class=\"input-full\" name=\"aq_blocks[aq_block_31][tabs][1][link]\" value=\"\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_31_tabs-1-image\">Image</label>
						</span>
						<span class=\"rightHalf\"><img class=\"screenshot\" src=\"\" alt=\"\"><input id=\"aq_block_31_tabs-1-imageid\" name=\"aq_blocks[aq_block_31][tabs][1][imageid]\" value=\"7583\" type=\"hidden\"><input id=\"aq_block_31_tabs-1-image\" readonly=\"\" class=\"input-full input-upload\" value=\"http://placehold.it/406x406/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_31][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></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_31_tabs-1-quote\">Quote</label>
						</span>
						<span class=\"rightHalf\"><textarea rows=\"5\" id=\"aq_block_31_tabs-1-quote\" class=\"textarea-full\" name=\"aq_blocks[aq_block_31][tabs][1][quote]\">Somewhere, something incredible is waiting to be known.</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></span></p>			</div>
		</li>
			<li id=\"aq_block_31_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Aristotle						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_31_tabs-2-name\">Client Name</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_31_tabs-2-name\" class=\"input-full\" name=\"aq_blocks[aq_block_31][tabs][2][name]\" value=\"Aristotle\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_31_tabs-2-company\">Company</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_31_tabs-2-company\" class=\"input-full\" name=\"aq_blocks[aq_block_31][tabs][2][company]\" value=\"\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_31_tabs-2-link\">Company link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_31_tabs-2-link\" class=\"input-full\" name=\"aq_blocks[aq_block_31][tabs][2][link]\" value=\"\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_31_tabs-2-image\">Image</label>
						</span>
						<span class=\"rightHalf\"><img class=\"screenshot\" src=\"\" alt=\"\"><input id=\"aq_block_31_tabs-2-imageid\" name=\"aq_blocks[aq_block_31][tabs][2][imageid]\" value=\"7582\" type=\"hidden\"><input id=\"aq_block_31_tabs-2-image\" readonly=\"\" class=\"input-full input-upload\" value=\"http://placehold.it/406x406/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_31][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></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_31_tabs-2-quote\">Quote</label>
						</span>
						<span class=\"rightHalf\"><textarea rows=\"5\" id=\"aq_block_31_tabs-2-quote\" class=\"textarea-full\" name=\"aq_blocks[aq_block_31][tabs][2][quote]\">The energy of the mind is the essence of life.</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></span></p>			</div>
		</li>
			<li id=\"aq_block_31_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\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_31_tabs-3-name\">Client Name</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_31_tabs-3-name\" class=\"input-full\" name=\"aq_blocks[aq_block_31][tabs][3][name]\" value=\"Pablo Picasso\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_31_tabs-3-company\">Company</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_31_tabs-3-company\" class=\"input-full\" name=\"aq_blocks[aq_block_31][tabs][3][company]\" value=\"\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_31_tabs-3-link\">Company link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_31_tabs-3-link\" class=\"input-full\" name=\"aq_blocks[aq_block_31][tabs][3][link]\" value=\"\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_31_tabs-3-image\">Image</label>
						</span>
						<span class=\"rightHalf\"><img class=\"screenshot\" src=\"\" alt=\"\"><input id=\"aq_block_31_tabs-3-imageid\" name=\"aq_blocks[aq_block_31][tabs][3][imageid]\" value=\"7581\" type=\"hidden\"><input id=\"aq_block_31_tabs-3-image\" readonly=\"\" class=\"input-full input-upload\" value=\"http://placehold.it/406x406/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_31][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></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_31_tabs-3-quote\">Quote</label>
						</span>
						<span class=\"rightHalf\"><textarea rows=\"5\" id=\"aq_block_31_tabs-3-quote\" class=\"textarea-full\" name=\"aq_blocks[aq_block_31][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></span></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_31][id_base]\" value=\"em_testimonials\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_31][name]\" value=\"Testimonials\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_31][order]\" value=\"2\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_31][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_31][parent]\" value=\"8\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-32\" class=\"block block-em_linkscarousel span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add Links Carousel\"><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_linkscarousel\" 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=\"color:#2E99E6;\"><i class=\"fa fa-link\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Links Carousel</div><div class=\"block-size\">12/12</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\">Links Carousel</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_32][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-32\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_32_mtheme_columns\">Columns</label>
							<span class=\"description_text\">
								No. of Columns
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_32_mtheme_columns\" name=\"aq_blocks[aq_block_32][mtheme_columns]\"><option value=\"6\">6</option><option value=\"5\">5</option><option value=\"4\" selected=\"selected\">4</option><option value=\"3\">3</option><option value=\"2\">2</option><option value=\"1\">1</option></select></span></div>			
				<ul id=\"aq-sortable-list-aq_block_32\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_32\">
								<li id=\"aq_block_32_tabs-sortable-item-1\" class=\"sortable-item ui-sortable-handle\" rel=\"1\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Century						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-1-name\">Name</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_32_tabs-1-name\" class=\"input-full\" name=\"aq_blocks[aq_block_32][tabs][1][name]\" value=\"Century\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-1-link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_32_tabs-1-link\" class=\"input-full\" name=\"aq_blocks[aq_block_32][tabs][1][link]\" value=\"#\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-1-image\">Image</label>
						</span>
						<span class=\"rightHalf\"><img class=\"screenshot\" src=\"\" alt=\"\"><input id=\"aq_block_32_tabs-1-imageid\" name=\"aq_blocks[aq_block_32][tabs][1][imageid]\" value=\"7574\" type=\"hidden\"><input id=\"aq_block_32_tabs-1-image\" readonly=\"\" class=\"input-full input-upload\" value=\"http://placehold.it/300x150/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_32][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></span></p>			</div>
		</li>
			<li id=\"aq_block_32_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Mahogany						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-2-name\">Name</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_32_tabs-2-name\" class=\"input-full\" name=\"aq_blocks[aq_block_32][tabs][2][name]\" value=\"Mahogany\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-2-link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_32_tabs-2-link\" class=\"input-full\" name=\"aq_blocks[aq_block_32][tabs][2][link]\" value=\"#\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-2-image\">Image</label>
						</span>
						<span class=\"rightHalf\"><img class=\"screenshot\" src=\"\" alt=\"\"><input id=\"aq_block_32_tabs-2-imageid\" name=\"aq_blocks[aq_block_32][tabs][2][imageid]\" value=\"7575\" type=\"hidden\"><input id=\"aq_block_32_tabs-2-image\" readonly=\"\" class=\"input-full input-upload\" value=\"http://placehold.it/300x150/83FDFB/ffffff/\" name=\"aq_blocks[aq_block_32][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></span></p>			</div>
		</li>
			<li id=\"aq_block_32_tabs-sortable-item-3\" class=\"sortable-item ui-sortable-handle\" rel=\"3\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Wild West Academy						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-3-name\">Name</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_32_tabs-3-name\" class=\"input-full\" name=\"aq_blocks[aq_block_32][tabs][3][name]\" value=\"Wild West Academy\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-3-link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_32_tabs-3-link\" class=\"input-full\" name=\"aq_blocks[aq_block_32][tabs][3][link]\" value=\"#\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-3-image\">Image</label>
						</span>
						<span class=\"rightHalf\"><img class=\"screenshot\" src=\"\" alt=\"\"><input id=\"aq_block_32_tabs-3-imageid\" name=\"aq_blocks[aq_block_32][tabs][3][imageid]\" value=\"7576\" type=\"hidden\"><input id=\"aq_block_32_tabs-3-image\" readonly=\"\" class=\"input-full input-upload\" value=\"http://placehold.it/300x150/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_32][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></span></p>			</div>
		</li>
			<li id=\"aq_block_32_tabs-sortable-item-4\" class=\"sortable-item ui-sortable-handle\" rel=\"4\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Woodsman						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-4-name\">Name</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_32_tabs-4-name\" class=\"input-full\" name=\"aq_blocks[aq_block_32][tabs][4][name]\" value=\"Woodsman\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-4-link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_32_tabs-4-link\" class=\"input-full\" name=\"aq_blocks[aq_block_32][tabs][4][link]\" value=\"#\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-4-image\">Image</label>
						</span>
						<span class=\"rightHalf\"><img class=\"screenshot\" src=\"\" alt=\"\"><input id=\"aq_block_32_tabs-4-imageid\" name=\"aq_blocks[aq_block_32][tabs][4][imageid]\" value=\"7577\" type=\"hidden\"><input id=\"aq_block_32_tabs-4-image\" readonly=\"\" class=\"input-full input-upload\" value=\"http://placehold.it/300x150/83FDFB/ffffff/\" name=\"aq_blocks[aq_block_32][tabs][4][image]\" type=\"text\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a href=\"#\" class=\"remove_image button\" rel=\"image\">Remove</a></span></p>			</div>
		</li>
			<li id=\"aq_block_32_tabs-sortable-item-5\" class=\"sortable-item ui-sortable-handle\" rel=\"5\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Hymalaya						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-5-name\">Name</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_32_tabs-5-name\" class=\"input-full\" name=\"aq_blocks[aq_block_32][tabs][5][name]\" value=\"Hymalaya\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-5-link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_32_tabs-5-link\" class=\"input-full\" name=\"aq_blocks[aq_block_32][tabs][5][link]\" value=\"#\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-5-image\">Image</label>
						</span>
						<span class=\"rightHalf\"><img class=\"screenshot\" src=\"\" alt=\"\"><input id=\"aq_block_32_tabs-5-imageid\" name=\"aq_blocks[aq_block_32][tabs][5][imageid]\" value=\"7578\" type=\"hidden\"><input id=\"aq_block_32_tabs-5-image\" readonly=\"\" class=\"input-full input-upload\" value=\"http://placehold.it/300x150/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_32][tabs][5][image]\" type=\"text\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a href=\"#\" class=\"remove_image button\" rel=\"image\">Remove</a></span></p>			</div>
		</li>
			<li id=\"aq_block_32_tabs-sortable-item-6\" class=\"sortable-item ui-sortable-handle\" rel=\"6\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Yellowoak						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-6-name\">Name</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_32_tabs-6-name\" class=\"input-full\" name=\"aq_blocks[aq_block_32][tabs][6][name]\" value=\"Yellowoak\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-6-link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_32_tabs-6-link\" class=\"input-full\" name=\"aq_blocks[aq_block_32][tabs][6][link]\" value=\"\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-6-image\">Image</label>
						</span>
						<span class=\"rightHalf\"><img class=\"screenshot\" src=\"\" alt=\"\"><input id=\"aq_block_32_tabs-6-imageid\" name=\"aq_blocks[aq_block_32][tabs][6][imageid]\" value=\"7579\" type=\"hidden\"><input id=\"aq_block_32_tabs-6-image\" readonly=\"\" class=\"input-full input-upload\" value=\"http://placehold.it/300x150/83FDFB/ffffff/\" name=\"aq_blocks[aq_block_32][tabs][6][image]\" type=\"text\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a href=\"#\" class=\"remove_image button\" rel=\"image\">Remove</a></span></p>			</div>
		</li>
			<li id=\"aq_block_32_tabs-sortable-item-7\" class=\"sortable-item ui-sortable-handle\" rel=\"7\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Anchorsea						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body\">

			<p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-7-name\">Name</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_32_tabs-7-name\" class=\"input-full\" name=\"aq_blocks[aq_block_32][tabs][7][name]\" value=\"Anchorsea\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-7-link\">Link</label>
						</span>
						<span class=\"rightHalf\"><input id=\"aq_block_32_tabs-7-link\" class=\"input-full\" name=\"aq_blocks[aq_block_32][tabs][7][link]\" value=\"#\" type=\"text\"></span></p><p class=\"tab-desc description\">
						<span class=\"leftHalf\">
							<label for=\"aq_block_32_tabs-7-image\">Image</label>
						</span>
						<span class=\"rightHalf\"><img class=\"screenshot\" src=\"\" alt=\"\"><input id=\"aq_block_32_tabs-7-imageid\" name=\"aq_blocks[aq_block_32][tabs][7][imageid]\" value=\"7580\" type=\"hidden\"><input id=\"aq_block_32_tabs-7-image\" readonly=\"\" class=\"input-full input-upload\" value=\"http://placehold.it/300x150/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_32][tabs][7][image]\" type=\"text\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a href=\"#\" class=\"remove_image button\" rel=\"image\">Remove</a></span></p>			</div>
		</li>
				</ul>
				<p></p>
				<a href=\"#\" rel=\"linkscarousel\" class=\"aq-sortable-add-new button\">Add New</a>
				<p></p>
			</div>
			<input class=\"id_base\" name=\"aq_blocks[aq_block_32][id_base]\" value=\"em_linkscarousel\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_32][name]\" value=\"Links Carousel\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_32][order]\" value=\"3\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_32][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_32][parent]\" value=\"8\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li></ul><div id=\"my-column-content-29\" 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\">Block ID</label><input class=\"blockID\" name=\"aq_blocks[aq_block_29][blockID]\" value=\"\" id=\"blockID\" type=\"text\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_29_container_type\">Boxed or Fullwidth</label>
							<span class=\"description_text\">
								Boxed or Fullwidth. For full columns
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_29_container_type\" name=\"aq_blocks[aq_block_29][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_29_text_intensity\">Text Intensity</label>
							<span class=\"description_text\">
								Text Intensity for headings types
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_29_text_intensity\" name=\"aq_blocks[aq_block_29][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_29_margin_top\">Margin top in pixels</label>
							<span class=\"description_text\">
								Margin top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_29_margin_top\" class=\"input-text-full\" value=\"20\" name=\"aq_blocks[aq_block_29][margin_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_29_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"description_text\">
								Margin bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_29_margin_bottom\" class=\"input-text-full\" value=\"50\" name=\"aq_blocks[aq_block_29][margin_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_29_padding_top\">Padding top in pixels</label>
							<span class=\"description_text\">
								Padding top in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_29_padding_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_29][padding_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_29_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"description_text\">
								Padding bottom in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_29_padding_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_29][padding_bottom]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_29_padding_sides\">Padding sides in pixels</label>
							<span class=\"description_text\">
								Padding sides in pixels
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_29_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_29][padding_sides]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_29_background_color\">Background color</label>
							<span class=\"description_text\">
								Background color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_29_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_29][background_color]\" data-default-color=\"\" type=\"text\"><input value=\"Clear\" class=\"button button-small hidden wp-picker-clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 0px; top: 182.133px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , 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));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 0%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-uploader\"><span class=\"leftHalf\">
							<label for=\"aq_block_29_background_image\">Background Image</label>
							<span class=\"description_text\">
								Background Image
							</span>
						</span><span class=\"rightHalf uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_29_background_image_imageid\" name=\"aq_blocks[aq_block_29][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_29_background_image\" class=\"input-full input-upload\" value=\"\" name=\"aq_blocks[aq_block_29][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></span></div><div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_29_background_scroll\">Scroll effect</label>
							<span class=\"description_text\">
								Scroll effect
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_29_background_scroll\" name=\"aq_blocks[aq_block_29][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</option></select></span></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_29][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_29][name]\" value=\"Column Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_29][order]\" value=\"8\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_29][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_29][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_29][number]\" value=\"29\" type=\"hidden\">				</div>
			<div style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li>
		<li style=\"top: auto; left: 0px;\" id=\"template-block-33\" class=\"block block-em_dividers span12   ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add a divider\"><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-33\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"33\" data-mblocktype=\"em_dividers\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle ui-sortable-handle\"><div class=\"block-icon\" style=\"color:#2E99E6;\"><i class=\"fa fa-ellipsis-h\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Dividers</div><div class=\"block-size\">12/12</div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-33\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Dividers</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_33][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-33\">
						<div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_33_mtheme_style\">Choose Divider</label>
							<span class=\"description_text\">
								Choose Divider
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_33_mtheme_style\" name=\"aq_blocks[aq_block_33][mtheme_style]\"><option value=\"blank\" selected=\"selected\">blank</option><option value=\"line\">line</option><option value=\"double\">double</option><option value=\"stripes\">stripes</option><option value=\"thinfade\">thinfade</option><option value=\"threelines\">threelines</option><option value=\"circleline\">circleline</option><option value=\"stripedcenter\">stripedcenter</option><option value=\"linedcenter\">linedcenter</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_33_mtheme_top\">Top Space in pixels</label>
							<span class=\"description_text\">
								Top Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_33_mtheme_top\" class=\"input-text-full\" value=\"0\" name=\"aq_blocks[aq_block_33][mtheme_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_33_mtheme_bottom\">Bottom Space pixels</label>
							<span class=\"description_text\">
								Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_33_mtheme_bottom\" class=\"input-text-full\" value=\"50\" name=\"aq_blocks[aq_block_33][mtheme_bottom]\" type=\"text\"></span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_33][id_base]\" value=\"em_dividers\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_33][name]\" value=\"Dividers\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_33][order]\" value=\"9\" 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=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-34\" class=\"block block-em_callout span12   ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add a Callout box\"><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_callout\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle ui-sortable-handle\"><div class=\"block-icon\" style=\"color:#2E99E6;\"><i class=\"fa fa-bullhorn\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Callout Box</div><div class=\"block-size\">12/12</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\">Callout Box</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_34][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-34\">
						<div class=\"description mtheme-input-type-is-animated\"><span class=\"leftHalf\">
							<label for=\"aq_block_34_mtheme_animated\">Animation type</label>
							<span class=\"description_text\">
								Animation type
							</span>
						</span><span class=\"rightHalf animated\"><select id=\"aq_block_34_mtheme_animated\" name=\"aq_blocks[aq_block_34][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_34_mtheme_title\">Title</label>
							<span class=\"description_text\">
								Title for Callout box
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_34_mtheme_title\" class=\"input-text-full\" value=\"Kinetika theme is packed with creative features\" name=\"aq_blocks[aq_block_34][mtheme_title]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-textarea\"><span class=\"leftHalf\">
							<label for=\"aq_block_34_mtheme_content\">Text for Callout</label>
							<span class=\"description_text\">
								Text for Callout
							</span>
						</span><span class=\"rightHalf textarea\"><textarea id=\"aq_block_34_mtheme_content\" class=\"textarea-  main-richtext-block\" name=\"aq_blocks[aq_block_34][mtheme_content]\" rows=\"10\">&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></span></div><div class=\"description mtheme-input-type-is-fontawesome-iconpicker\"><span class=\"leftHalf\">
							<label for=\"aq_block_34_mtheme_button_icon\">Select icon</label>
							<span class=\"description_text\">
								Select an icon
							</span>
						</span><span class=\"rightHalf fontawesome-iconpicker\"><div class=\"mtheme-pb-icon-selector\"><a href=\"#mtheme-pb-icon-selector-modal\" data-toggle=\"stackablemodal\">Choose icon</a><input id=\"aq_block_34_mtheme_button_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_34][mtheme_button_icon]\" value=\"\" type=\"hidden\"><i class=\"fontawesome_icon preview \"></i></div></span></div><div class=\"description mtheme-input-type-is-color\"><span class=\"leftHalf\">
							<label for=\"aq_block_34_mtheme_button_color\">Button color</label>
							<span class=\"description_text\">
								Button color
							</span>
						</span><span class=\"rightHalf color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a data-current=\"Current Color\" title=\"Select Color\" tabindex=\"0\" class=\"wp-color-result\"></a><span class=\"wp-picker-input-wrap\"><input style=\"display: none;\" id=\"aq_block_34_mtheme_button_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_34][mtheme_button_color]\" data-default-color=\"\" type=\"text\"><input value=\"Clear\" class=\"button button-small hidden wp-picker-clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div style=\"display: none; width: 255px; height: 202.125px; padding-bottom: 23.2209px;\" class=\"iris-picker iris-mozilla iris-border\"><div class=\"iris-picker-inner\"><div style=\"width: 182.125px; height: 182.125px;\" class=\"iris-square\"><a style=\"left: 0px; top: 182.133px;\" class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div style=\"background-image: -moz-linear-gradient(left center , 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));\" class=\"iris-square-inner iris-square-horiz\"></div><div style=\"background-image: -moz-linear-gradient(center top , transparent, rgb(0, 0, 0));\" class=\"iris-square-inner iris-square-vert\"></div></div><div style=\"height: 205.346px; width: 28.2px; background-image: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0));\" class=\"iris-slider iris-strip\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span style=\"bottom: 0%;\" class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\"></span></div></div></div><div class=\"iris-palette-container\"><a style=\"background-color: rgb(0, 0, 0); height: 19.5784px; width: 19.5784px; margin-left: 0px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(255, 255, 255); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 51, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(221, 153, 51); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(238, 238, 34); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(129, 215, 66); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(30, 115, 190); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a><a style=\"background-color: rgb(130, 36, 227); height: 19.5784px; width: 19.5784px; margin-left: 3.6425px;\" class=\"iris-palette\" tabindex=\"0\"></a></div></div></div></div></span></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_34_mtheme_button_text\">Button Text</label>
							<span class=\"description_text\">
								Button Text
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_34_mtheme_button_text\" class=\"input-text-full\" value=\"Purchase\" name=\"aq_blocks[aq_block_34][mtheme_button_text]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_34_mtheme_button_link\">Button Link</label>
							<span class=\"description_text\">
								Button Link
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_34_mtheme_button_link\" class=\"input-text-full\" value=\"#\" name=\"aq_blocks[aq_block_34][mtheme_button_link]\" type=\"text\"></span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_34][id_base]\" value=\"em_callout\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_34][name]\" value=\"Callout Box\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_34][order]\" value=\"10\" 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=\"0\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li><li style=\"top: auto; left: 0px;\" id=\"template-block-35\" class=\"block block-em_dividers span12   ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Add a divider\"><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-35\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"35\" data-mblocktype=\"em_dividers\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle ui-sortable-handle\"><div class=\"block-icon\" style=\"color:#2E99E6;\"><i class=\"fa fa-ellipsis-h\"></i></div><ul class=\"resizeButtons\">
		 							<li>
				 						<a href=\"#\" class=\"resizePlus\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"resizeMinus\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Dividers</div><div class=\"block-size\">12/12</div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-35\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Dividers</h4>
								<label for=\"blockID\">Block ID</label>
								<span class=\"description_text\">Enter an ID for this block.</span>
								<input name=\"aq_blocks[aq_block_35][blockID]\" value=\"\" class=\"blockID\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-35\">
						<div class=\"description mtheme-input-type-is-select\"><span class=\"leftHalf\">
							<label for=\"aq_block_35_mtheme_style\">Choose Divider</label>
							<span class=\"description_text\">
								Choose Divider
							</span>
						</span><span class=\"rightHalf select\"><select id=\"aq_block_35_mtheme_style\" name=\"aq_blocks[aq_block_35][mtheme_style]\"><option value=\"blank\" selected=\"selected\">blank</option><option value=\"line\">line</option><option value=\"double\">double</option><option value=\"stripes\">stripes</option><option value=\"thinfade\">thinfade</option><option value=\"threelines\">threelines</option><option value=\"circleline\">circleline</option><option value=\"stripedcenter\">stripedcenter</option><option value=\"linedcenter\">linedcenter</option></select></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_35_mtheme_top\">Top Space in pixels</label>
							<span class=\"description_text\">
								Top Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_35_mtheme_top\" class=\"input-text-full\" value=\"0\" name=\"aq_blocks[aq_block_35][mtheme_top]\" type=\"text\"></span></div><div class=\"description mtheme-input-type-is-text\"><span class=\"leftHalf\">
							<label for=\"aq_block_35_mtheme_bottom\">Bottom Space pixels</label>
							<span class=\"description_text\">
								Bottom Spacing
							</span>
						</span><span class=\"rightHalf text\"><input id=\"aq_block_35_mtheme_bottom\" class=\"input-text-full\" value=\"50\" name=\"aq_blocks[aq_block_35][mtheme_bottom]\" type=\"text\"></span></div><input class=\"id_base\" name=\"aq_blocks[aq_block_35][id_base]\" value=\"em_dividers\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_35][name]\" value=\"Dividers\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_35][order]\" value=\"11\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_35][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_35][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_35][number]\" value=\"35\" 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 style=\"z-index: 90;\" class=\"ui-resizable-handle ui-resizable-e\"></div></li>							