
								<li id=\"template-block-1\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\">
				<ul class=\"block-controls\">
					<li class=\"block-control-actions cf\">
						<a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove Column Container\"><i class=\"fa fa-trash\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#my-column-content-1\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit Column Container\"><i class=\"fa fa-pencil\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\" data-toggle=\"modal\"><i class=\"fa fa-upload\"></i></a>
					</li>
				</ul>
				<dt class=\"block-handle ui-sortable-handle\">
	 				<div class=\"block-icon\" style=\"color:none;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span>
					<div class=\"blocknote-self\">Meet the team</div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-1\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-2\" class=\"block block-em_sectionheading span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-2\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"2\" data-mblocktype=\"em_sectionheading\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(255,105,97,0.3) 0%, rgba(255,105,97,1) 100%);
background: -webkit-linear-gradient(left, rgba(255,105,97,0.5) 0%,rgba(255,105,97,1) 100%);
background: linear-gradient(to right, rgba(255,105,97,0.5) 0%,rgba(255,105,97,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#FF6961a5\', endColorstr=\'#FF6961a5\',GradientType=1 );\"><i class=\"fa fa-header\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Section Heading</div><div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-2\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Section Heading</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_2][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_2][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-2\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_2_mtheme_animated\" name=\"aq_blocks[aq_block_2][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_title\">Section Heading text</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_title\" class=\"input-text-full\" value=\"Meet the Team\" name=\"aq_blocks[aq_block_2][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_subtitle\">Section subtitle (optional)</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_subtitle\" class=\"input-text-full\" value=\"The company talents\" name=\"aq_blocks[aq_block_2][mtheme_subtitle]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_align\">Align text</label>
							<span class=\"forminputdescription\">
								Align text
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_2_mtheme_align\" name=\"aq_blocks[aq_block_2][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_size\">Heading size</label>
							<span class=\"forminputdescription\">
								Heading size
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_2_mtheme_size\" name=\"aq_blocks[aq_block_2][mtheme_size]\"><option value=\"1\" selected=\"selected\">h1</option><option value=\"2\">h2</option><option value=\"3\">h3</option><option value=\"4\">h4</option><option value=\"5\">h5</option><option value=\"6\">h6</option></select></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_content_richtext\">Content</label>
							<span class=\"forminputdescription\">
								Add content
							</span>
						</div><div class=\"formview-rightside 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\">&lt;p&gt;Vivamus vel mi lorem. Sed vitae felis nisl, at venenatis tortor. In at velit ac turpis aliquam volutpat. Ut et nibh augue. Integer imperdiet convallis massa nec gravida. Sed eleifend porta urna. Praesent non nisi tellus, ut lobortis massa. Sed pretium pretium elit et vulputate. Quisque nec justo lacus. Phasellus tristique sapien ut dui sagittis feugiat. Pellentesque quis leo.&lt;/p&gt;</textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_button\">Button Text</label>
							<span class=\"forminputdescription\">
								Button Text
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_button\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_2][mtheme_button]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_button_link\">Button link</label>
							<span class=\"forminputdescription\">
								Button link
							</span>
						</div><div class=\"formview-rightside 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\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_width\">Width in percent</label>
							<span class=\"forminputdescription\">
								Width in percent
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_width\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_2][mtheme_width]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_top\">Padding Top in pixels</label>
							<span class=\"forminputdescription\">
								Top Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_top\" class=\"input-text-full\" value=\"0\" name=\"aq_blocks[aq_block_2][mtheme_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"forminputdescription\">
								Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_bottom\" class=\"input-text-full\" value=\"10\" name=\"aq_blocks[aq_block_2][mtheme_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_2_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"forminputdescription\">
								Margin Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_2_mtheme_marginbottom\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_2][mtheme_marginbottom]\" type=\"text\"></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_2][id_base]\" value=\"em_sectionheading\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_2][name]\" value=\"Section Heading\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_2][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_2][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_2][parent]\" value=\"1\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_2][number]\" value=\"2\" type=\"hidden\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-3\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-3\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"3\" 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=\"background: -moz-linear-gradient(left, rgba(255,133,27,0.3) 0%, rgba(255,133,27,1) 100%);
background: -webkit-linear-gradient(left, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
background: linear-gradient(to right, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#FF851Ba5\', endColorstr=\'#FF851Ba5\',GradientType=1 );\"><i class=\"simpleicon-user-follow\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-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\">Staff</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_3][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_3][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-3\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_3_mtheme_animated\" name=\"aq_blocks[aq_block_3][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\" selected=\"selected\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_mtheme_title\">Staff title</label>
							<span class=\"forminputdescription\">
								Staff title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_3_mtheme_title\" class=\"input-text-full\" value=\"CEO\" name=\"aq_blocks[aq_block_3][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_mtheme_name\">Staff name</label>
							<span class=\"forminputdescription\">
								Staff name
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_3_mtheme_name\" class=\"input-text-full\" value=\"Jane Doe\" name=\"aq_blocks[aq_block_3][mtheme_name]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_mtheme_image\">Staff image</label>
							<span class=\"forminputdescription\">
								Staff image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://192.168.1.3/wordpress/kinetika/wp-content/uploads/sites/3/2015/02/staff1-150x150.jpg\" alt=\"\">
						<input id=\"aq_block_3_mtheme_image_imageid\" name=\"aq_blocks[aq_block_3][mtheme_imageid]\" value=\"7566\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_3_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://placehold.it/406x406/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_3][mtheme_image]\" type=\"text\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_mtheme_description\">Staff Description</label>
							<span class=\"forminputdescription\">
								Staff Description
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_3_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_3_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_3][mtheme_description]\" id=\"aq_block_3_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div>			
				<ul id=\"aq-sortable-list-aq_block_3\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_3\">
								<li id=\"aq_block_3_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 cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_3_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_3_tabs-1-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_3][tabs][1][social_icon]\" value=\"fa fa-facebook\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-facebook\"></i></div></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_3_tabs-1-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_3_tabs-1-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_3][tabs][1][social_text]\" value=\"Facebook\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_3_tabs-1-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_3_tabs-1-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_3][tabs][1][social_link]\" value=\"http://www.facebook.com/\" type=\"text\"></div><p></p>			</div>
		</li>
			<li id=\"aq_block_3_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 cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_3_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_3_tabs-2-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_3][tabs][2][social_icon]\" value=\"fa fa-twitter\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-twitter\"></i></div></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_3_tabs-2-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_3_tabs-2-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_3][tabs][2][social_text]\" value=\"Twitter\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_3_tabs-2-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_3_tabs-2-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_3][tabs][2][social_link]\" value=\"http://www.twitter.com/\" type=\"text\"></div><p></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_3][id_base]\" value=\"em_staff\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_3][name]\" value=\"Staff\" 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=\"span3\" 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 class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-4\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-4\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"4\" data-mblocktype=\"em_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=\"background: -moz-linear-gradient(left, rgba(255,133,27,0.3) 0%, rgba(255,133,27,1) 100%);
background: -webkit-linear-gradient(left, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
background: linear-gradient(to right, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#FF851Ba5\', endColorstr=\'#FF851Ba5\',GradientType=1 );\"><i class=\"simpleicon-user-follow\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-4\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Staff</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_4][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_4][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-4\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_4_mtheme_animated\" name=\"aq_blocks[aq_block_4][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\" 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></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_title\">Staff title</label>
							<span class=\"forminputdescription\">
								Staff title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_4_mtheme_title\" class=\"input-text-full\" value=\"President\" name=\"aq_blocks[aq_block_4][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_name\">Staff name</label>
							<span class=\"forminputdescription\">
								Staff name
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_4_mtheme_name\" class=\"input-text-full\" value=\"Jane Doe\" name=\"aq_blocks[aq_block_4][mtheme_name]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_image\">Staff image</label>
							<span class=\"forminputdescription\">
								Staff image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://192.168.1.3/wordpress/kinetika/wp-content/uploads/sites/3/2015/02/staff2-150x150.jpg\" alt=\"\">
						<input id=\"aq_block_4_mtheme_image_imageid\" name=\"aq_blocks[aq_block_4][mtheme_imageid]\" value=\"7567\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_4_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://placehold.it/406x406/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_4][mtheme_image]\" type=\"text\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_description\">Staff Description</label>
							<span class=\"forminputdescription\">
								Staff Description
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_4_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_4_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_4][mtheme_description]\" id=\"aq_block_4_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div>			
				<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>
							Facebook						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_4_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_4_tabs-1-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_4][tabs][1][social_icon]\" value=\"fa fa-facebook\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-facebook\"></i></div></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_4_tabs-1-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_4_tabs-1-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][1][social_text]\" value=\"Facebook\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_4_tabs-1-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_4_tabs-1-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][1][social_link]\" value=\"http://www.facebook.com/\" type=\"text\"></div><p></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>
							Twitter						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_4_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_4_tabs-2-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_4][tabs][2][social_icon]\" value=\"fa fa-twitter\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-twitter\"></i></div></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_4_tabs-2-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_4_tabs-2-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][2][social_text]\" value=\"Twitter\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_4_tabs-2-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_4_tabs-2-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_4][tabs][2][social_link]\" value=\"http://www.twitter.com/\" type=\"text\"></div><p></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_4][id_base]\" value=\"em_staff\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_4][name]\" value=\"Staff\" 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=\"span3\" 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 class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-5\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-5\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"5\" data-mblocktype=\"em_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=\"background: -moz-linear-gradient(left, rgba(255,133,27,0.3) 0%, rgba(255,133,27,1) 100%);
background: -webkit-linear-gradient(left, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
background: linear-gradient(to right, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#FF851Ba5\', endColorstr=\'#FF851Ba5\',GradientType=1 );\"><i class=\"simpleicon-user-follow\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-5\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Staff</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_5][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_5][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-5\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_5_mtheme_animated\" name=\"aq_blocks[aq_block_5][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\" 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></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_title\">Staff title</label>
							<span class=\"forminputdescription\">
								Staff title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_5_mtheme_title\" class=\"input-text-full\" value=\"Chairman\" name=\"aq_blocks[aq_block_5][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_name\">Staff name</label>
							<span class=\"forminputdescription\">
								Staff name
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_5_mtheme_name\" class=\"input-text-full\" value=\"John Doe\" name=\"aq_blocks[aq_block_5][mtheme_name]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_image\">Staff image</label>
							<span class=\"forminputdescription\">
								Staff image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://192.168.1.3/wordpress/kinetika/wp-content/uploads/sites/3/2015/02/staff3-150x150.jpg\" alt=\"\">
						<input id=\"aq_block_5_mtheme_image_imageid\" name=\"aq_blocks[aq_block_5][mtheme_imageid]\" value=\"7568\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_5_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://placehold.it/406x406/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_5][mtheme_image]\" type=\"text\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_description\">Staff Description</label>
							<span class=\"forminputdescription\">
								Staff Description
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_5_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_5_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_5][mtheme_description]\" id=\"aq_block_5_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div>			
				<ul id=\"aq-sortable-list-aq_block_5\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_5\">
								<li id=\"aq_block_5_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 cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_5_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_5_tabs-1-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_5][tabs][1][social_icon]\" value=\"fa fa-facebook\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-facebook\"></i></div></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_5_tabs-1-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_5_tabs-1-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_5][tabs][1][social_text]\" value=\"Facebook\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_5_tabs-1-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_5_tabs-1-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_5][tabs][1][social_link]\" value=\"http://www.facebook.com/\" type=\"text\"></div><p></p>			</div>
		</li>
			<li id=\"aq_block_5_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 cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_5_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_5_tabs-2-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_5][tabs][2][social_icon]\" value=\"fa fa-twitter\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-twitter\"></i></div></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_5_tabs-2-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_5_tabs-2-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_5][tabs][2][social_text]\" value=\"Twitter\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_5_tabs-2-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_5_tabs-2-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_5][tabs][2][social_link]\" value=\"http://www.twitter.com/\" type=\"text\"></div><p></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_5][id_base]\" value=\"em_staff\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_5][name]\" value=\"Staff\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_5][order]\" value=\"4\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_5][size]\" value=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_5][parent]\" value=\"1\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_5][number]\" value=\"5\" type=\"hidden\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-6\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-6\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"6\" data-mblocktype=\"em_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=\"background: -moz-linear-gradient(left, rgba(255,133,27,0.3) 0%, rgba(255,133,27,1) 100%);
background: -webkit-linear-gradient(left, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
background: linear-gradient(to right, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#FF851Ba5\', endColorstr=\'#FF851Ba5\',GradientType=1 );\"><i class=\"simpleicon-user-follow\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-6\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Staff</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_6][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_6][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-6\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_6_mtheme_animated\" name=\"aq_blocks[aq_block_6][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\" selected=\"selected\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_title\">Staff title</label>
							<span class=\"forminputdescription\">
								Staff title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_6_mtheme_title\" class=\"input-text-full\" value=\"Managing Director\" name=\"aq_blocks[aq_block_6][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_name\">Staff name</label>
							<span class=\"forminputdescription\">
								Staff name
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_6_mtheme_name\" class=\"input-text-full\" value=\"Jane Doe\" name=\"aq_blocks[aq_block_6][mtheme_name]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_image\">Staff image</label>
							<span class=\"forminputdescription\">
								Staff image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://192.168.1.3/wordpress/kinetika/wp-content/uploads/sites/3/2015/02/staff4-150x150.jpg\" alt=\"\">
						<input id=\"aq_block_6_mtheme_image_imageid\" name=\"aq_blocks[aq_block_6][mtheme_imageid]\" value=\"7569\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_6_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://placehold.it/406x406/2B99FC/ffffff/\" name=\"aq_blocks[aq_block_6][mtheme_image]\" type=\"text\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_description\">Staff Description</label>
							<span class=\"forminputdescription\">
								Staff Description
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_6_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_6_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_6][mtheme_description]\" id=\"aq_block_6_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div>			
				<ul id=\"aq-sortable-list-aq_block_6\" class=\"aq-sortable-list ui-sortable\" rel=\"aq_block_6\">
								<li id=\"aq_block_6_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 cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_6_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_6_tabs-1-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_6][tabs][1][social_icon]\" value=\"fa fa-facebook\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-facebook\"></i></div></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_6_tabs-1-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_6_tabs-1-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_6][tabs][1][social_text]\" value=\"Facebook\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_6_tabs-1-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_6_tabs-1-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_6][tabs][1][social_link]\" value=\"http://www.facebook.com/\" type=\"text\"></div><p></p>			</div>
		</li>
			<li id=\"aq_block_6_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 cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_6_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_6_tabs-2-social_icon\" class=\"mtheme-pb-selected-icon\" name=\"aq_blocks[aq_block_6][tabs][2][social_icon]\" value=\"fa fa-twitter\" type=\"hidden\"><i class=\"fontawesome_icon preview fa fa-twitter\"></i></div></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_6_tabs-2-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_6_tabs-2-social_text\" class=\"input-full\" name=\"aq_blocks[aq_block_6][tabs][2][social_text]\" value=\"Twitter\" type=\"text\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_6_tabs-2-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><input id=\"aq_block_6_tabs-2-social_link\" class=\"input-full\" name=\"aq_blocks[aq_block_6][tabs][2][social_link]\" value=\"http://www.twitter.com/\" type=\"text\"></div><p></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_6][id_base]\" value=\"em_staff\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_6][name]\" value=\"Staff\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_6][order]\" value=\"5\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_6][size]\" value=\"span3\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_6][parent]\" value=\"1\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_6][number]\" value=\"6\" type=\"hidden\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-7\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-7\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"7\" data-mblocktype=\"em_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=\"background: -moz-linear-gradient(left, rgba(255,133,27,0.3) 0%, rgba(255,133,27,1) 100%);
background: -webkit-linear-gradient(left, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
background: linear-gradient(to right, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#FF851Ba5\', endColorstr=\'#FF851Ba5\',GradientType=1 );\"><i class=\"simpleicon-user-follow\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-7\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Staff</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_7][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_7][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-7\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_7_mtheme_animated\" name=\"aq_blocks[aq_block_7][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\" selected=\"selected\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_title\">Staff title</label>
							<span class=\"forminputdescription\">
								Staff title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_7_mtheme_title\" class=\"input-text-full\" value=\"Marketing Director\" name=\"aq_blocks[aq_block_7][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_name\">Staff name</label>
							<span class=\"forminputdescription\">
								Staff name
							</span>
						</div><div class=\"formview-rightside 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\"></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_image\">Staff image</label>
							<span class=\"forminputdescription\">
								Staff image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://192.168.1.3/wordpress/kinetika/wp-content/uploads/sites/3/2015/02/staff5-150x150.jpg\" alt=\"\">
						<input id=\"aq_block_7_mtheme_image_imageid\" name=\"aq_blocks[aq_block_7][mtheme_imageid]\" value=\"7570\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_7_mtheme_image\" class=\"input-full imagefile-uploader\" 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></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_description\">Staff Description</label>
							<span class=\"forminputdescription\">
								Staff Description
							</span>
						</div><div class=\"formview-rightside 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>

</div></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 cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_7_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_7_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></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_7_tabs-1-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_7_tabs-1-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></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 cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_7_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_7_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></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_7_tabs-2-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_7_tabs-2-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></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=\"6\" 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=\"1\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_7][number]\" value=\"7\" type=\"hidden\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-8\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-8\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"8\" data-mblocktype=\"em_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=\"background: -moz-linear-gradient(left, rgba(255,133,27,0.3) 0%, rgba(255,133,27,1) 100%);
background: -webkit-linear-gradient(left, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
background: linear-gradient(to right, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#FF851Ba5\', endColorstr=\'#FF851Ba5\',GradientType=1 );\"><i class=\"simpleicon-user-follow\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-8\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Staff</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_8][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_8][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-8\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_8_mtheme_animated\" name=\"aq_blocks[aq_block_8][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_title\">Staff title</label>
							<span class=\"forminputdescription\">
								Staff title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_8_mtheme_title\" class=\"input-text-full\" value=\"Advertising Director\" name=\"aq_blocks[aq_block_8][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_name\">Staff name</label>
							<span class=\"forminputdescription\">
								Staff name
							</span>
						</div><div class=\"formview-rightside 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\"></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_image\">Staff image</label>
							<span class=\"forminputdescription\">
								Staff image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://192.168.1.3/wordpress/kinetika/wp-content/uploads/sites/3/2015/02/staff6-150x150.jpg\" alt=\"\">
						<input id=\"aq_block_8_mtheme_image_imageid\" name=\"aq_blocks[aq_block_8][mtheme_imageid]\" value=\"7571\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_8_mtheme_image\" class=\"input-full imagefile-uploader\" 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></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_description\">Staff Description</label>
							<span class=\"forminputdescription\">
								Staff Description
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_8_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_8_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_8][mtheme_description]\" id=\"aq_block_8_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div>			
				<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 cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_8_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_8_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></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_8_tabs-1-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_8_tabs-1-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></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 cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_8_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_8_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></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_8_tabs-2-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_8_tabs-2-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></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=\"7\" 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=\"1\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_8][number]\" value=\"8\" type=\"hidden\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-9\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-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=\"background: -moz-linear-gradient(left, rgba(255,133,27,0.3) 0%, rgba(255,133,27,1) 100%);
background: -webkit-linear-gradient(left, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
background: linear-gradient(to right, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#FF851Ba5\', endColorstr=\'#FF851Ba5\',GradientType=1 );\"><i class=\"simpleicon-user-follow\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-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>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_9][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_9][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-9\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_9_mtheme_animated\" name=\"aq_blocks[aq_block_9][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\" selected=\"selected\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_title\">Staff title</label>
							<span class=\"forminputdescription\">
								Staff title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_9_mtheme_title\" class=\"input-text-full\" value=\"Human Resource Manager\" name=\"aq_blocks[aq_block_9][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_name\">Staff name</label>
							<span class=\"forminputdescription\">
								Staff name
							</span>
						</div><div class=\"formview-rightside 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\"></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_image\">Staff image</label>
							<span class=\"forminputdescription\">
								Staff image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://192.168.1.3/wordpress/kinetika/wp-content/uploads/sites/3/2015/02/staff7-150x150.jpg\" alt=\"\">
						<input id=\"aq_block_9_mtheme_image_imageid\" name=\"aq_blocks[aq_block_9][mtheme_imageid]\" value=\"7572\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_9_mtheme_image\" class=\"input-full imagefile-uploader\" 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></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_description\">Staff Description</label>
							<span class=\"forminputdescription\">
								Staff Description
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_9_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_9_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_9][mtheme_description]\" id=\"aq_block_9_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div>			
				<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 cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_9_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_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></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_9_tabs-1-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_9_tabs-1-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></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 cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_9_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_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></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_9_tabs-2-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_9_tabs-2-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></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=\"8\" 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=\"1\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_9][number]\" value=\"9\" type=\"hidden\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-10\" class=\"block block-em_staff span3 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-10\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"10\" data-mblocktype=\"em_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=\"background: -moz-linear-gradient(left, rgba(255,133,27,0.3) 0%, rgba(255,133,27,1) 100%);
background: -webkit-linear-gradient(left, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
background: linear-gradient(to right, rgba(255,133,27,0.5) 0%,rgba(255,133,27,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#FF851Ba5\', endColorstr=\'#FF851Ba5\',GradientType=1 );\"><i class=\"simpleicon-user-follow\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Staff</div><div class=\"block-size\">3/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-10\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Staff</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input name=\"aq_blocks[aq_block_10][blockID]\" value=\"\" class=\"blockID\" type=\"text\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input name=\"aq_blocks[aq_block_10][blockNote]\" value=\"\" class=\"blockNote\" type=\"text\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-10\">
									<div class=\"description cf\">
			<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_10_mtheme_animated\" name=\"aq_blocks[aq_block_10][mtheme_animated]\"><option value=\"none\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\" selected=\"selected\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_title\">Staff title</label>
							<span class=\"forminputdescription\">
								Staff title
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_10_mtheme_title\" class=\"input-text-full\" value=\"Sales Director\" name=\"aq_blocks[aq_block_10][mtheme_title]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_name\">Staff name</label>
							<span class=\"forminputdescription\">
								Staff name
							</span>
						</div><div class=\"formview-rightside 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\"></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_image\">Staff image</label>
							<span class=\"forminputdescription\">
								Staff image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://192.168.1.3/wordpress/kinetika/wp-content/uploads/sites/3/2015/02/staff8-150x150.jpg\" alt=\"\">
						<input id=\"aq_block_10_mtheme_image_imageid\" name=\"aq_blocks[aq_block_10][mtheme_imageid]\" value=\"7573\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_10_mtheme_image\" class=\"input-full imagefile-uploader\" 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></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_description\">Staff Description</label>
							<span class=\"forminputdescription\">
								Staff Description
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_10_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_10_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_10][mtheme_description]\" id=\"aq_block_10_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div>			
				<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 cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-1-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_10_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></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-1-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-1-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></p>			</div>
		</li>
			<li id=\"aq_block_10_tabs-sortable-item-2\" class=\"sortable-item ui-sortable-handle\" rel=\"2\">
				<div class=\"sortable-head cf\">
					<div class=\"sortable-title\">
						<strong>
							Twitter						</strong>
					</div>
					<div class=\"sortable-out-delete\">
					</div>
					<div class=\"sortable-handle\">
						<a href=\"#\"></a>
					</div>
				</div>
				<div class=\"sortable-body cf\">

			<p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-2-social_icon\">Choose a Fontawesome icon</label>
						</div>
						<div class=\"formview-rightside\"><div class=\"pagebuilder-icon-picker\"><a href=\"#pagebuilder-icon-picker-modal\" data-toggle=\"stackablemodal\">Choose icon</a><a class=\"mtheme-pb-remove-icon\">Remove icon</a><input id=\"aq_block_10_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></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-2-social_text\">Social Text</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></p><p class=\"tab-desc description\">
						</p><div class=\"formview-leftside\">
							<label for=\"aq_block_10_tabs-2-social_link\">Link</label>
						</div>
						<div class=\"formview-rightside\"><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\"></div><p></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=\"9\" 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=\"1\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_10][number]\" value=\"10\" type=\"hidden\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li></ul><div id=\"my-column-content-1\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" name=\"aq_blocks[aq_block_1][blockID]\" value=\"\" id=\"blockID\" type=\"text\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" name=\"aq_blocks[aq_block_1][blockNote]\" value=\"Meet the team\" id=\"blockNote\" type=\"text\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_container_type\">Boxed or Fullwidth</label>
							<span class=\"forminputdescription\">
								Boxed or Fullwidth. For full columns
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_1_container_type\" name=\"aq_blocks[aq_block_1][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_1_text_intensity\" name=\"aq_blocks[aq_block_1][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_margin_top\">Margin top in pixels</label>
							<span class=\"forminputdescription\">
								Margin top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_1_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][margin_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"forminputdescription\">
								Margin bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_1_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][margin_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_padding_top\">Padding top in pixels</label>
							<span class=\"forminputdescription\">
								Padding top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_1_padding_top\" class=\"input-text-full\" value=\"185\" name=\"aq_blocks[aq_block_1][padding_top]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"forminputdescription\">
								Padding bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_1_padding_bottom\" class=\"input-text-full\" value=\"80\" name=\"aq_blocks[aq_block_1][padding_bottom]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_padding_sides\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input id=\"aq_block_1_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_1][padding_sides]\" type=\"text\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a tabindex=\"0\" class=\"wp-color-result\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_1_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_1][background_color]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center top , rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_gradient_color\">Combine with background color to create Gradients</label>
							<span class=\"forminputdescription\">
								Apply Gradient color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><a tabindex=\"0\" class=\"wp-color-result\" title=\"Select Color\" data-current=\"Current Color\"></a><span class=\"wp-picker-input-wrap\"><input id=\"aq_block_1_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_1][gradient_color]\" data-default-color=\"\" style=\"display: none;\" type=\"text\"><input class=\"button button-small hidden wp-picker-clear\" value=\"Clear\" type=\"button\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-mozilla iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -moz-linear-gradient(left center , rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -moz-linear-gradient(center top , rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -moz-linear-gradient(center top , rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_1_gradient_angle\" name=\"aq_blocks[aq_block_1][gradient_angle]\"><option value=\"none\">none</option><option value=\"to_bottom\">to bottom</option><option value=\"to_top\">to top</option><option value=\"to_top_right\">to top right</option><option value=\"to_top_left\">to top left</option><option value=\"to_bottom_right\">to bottom right</option><option value=\"to_bottom_left\">to bottom left</option></select></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_background_image\">Background Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input id=\"aq_block_1_background_image_imageid\" name=\"aq_blocks[aq_block_1][background_imageid]\" value=\"\" type=\"hidden\"><input readonly=\"\" id=\"aq_block_1_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_1][background_image]\" type=\"text\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_1_background_scroll\">Scroll effect</label>
							<span class=\"forminputdescription\">
								Scroll effect
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_1_background_scroll\" name=\"aq_blocks[aq_block_1][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</option></select></div></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input class=\"id_base\" name=\"aq_blocks[aq_block_1][id_base]\" value=\"em_column_block\" type=\"hidden\"><input class=\"name\" name=\"aq_blocks[aq_block_1][name]\" value=\"Fullwidth Container\" type=\"hidden\"><input class=\"order\" name=\"aq_blocks[aq_block_1][order]\" value=\"1\" type=\"hidden\"><input class=\"size\" name=\"aq_blocks[aq_block_1][size]\" value=\"span12\" type=\"hidden\"><input class=\"parent\" name=\"aq_blocks[aq_block_1][parent]\" value=\"0\" type=\"hidden\"><input class=\"number\" name=\"aq_blocks[aq_block_1][number]\" value=\"1\" type=\"hidden\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
									