<li id=\"template-block-3\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\">
				<ul class=\"block-controls\">
					<li class=\"block-control-actions cf\">
						<a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove Column Container\"><i class=\"fa fa-trash\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#my-column-content-3\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit Column Container\"><i class=\"fa fa-pencil\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\" data-toggle=\"modal\"><i class=\"fa fa-upload\"></i></a>
					</li>
				</ul>
				<dt class=\"block-handle ui-sortable-handle\">
	 				<div class=\"block-icon\" style=\"color:none;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span>
					<div class=\"blocknote-self\"></div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-3\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-4\" class=\"block block-em_singleimage span2 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-4\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"4\" data-mblocktype=\"em_singleimage\" 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(150,111,214,0.3) 0%, rgba(150,111,214,1) 100%);
background: -webkit-linear-gradient(left, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
background: linear-gradient(to right, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#966FD6a5\', endColorstr=\'#966FD6a5\',GradientType=1 );\"><i class=\"simpleicon-picture\"></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\">Single Image</div><div class=\"block-size\">2/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-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\">Single Image</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_4][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_4][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-4\">
						<div class=\"description mtheme-input-type-is-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\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_4_mtheme_animated\" name=\"aq_blocks[aq_block_4][mtheme_animated]\"><option value=\"none\" selected=\"selected\">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\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div></div><h3 class=\"group\">Spacing</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_paddingtop\">Top Space</label>
							<span class=\"forminputdescription\">
								Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_4_mtheme_paddingtop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_4][mtheme_paddingtop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_paddingbottom\">Bottom Space</label>
							<span class=\"forminputdescription\">
								Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">20</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">20</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">20</span></span><input type=\"text\" id=\"aq_block_4_mtheme_paddingbottom\" class=\"input-text-full responsive-data-text\" value=\"20\" name=\"aq_blocks[aq_block_4][mtheme_paddingbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_margintop\">Margin Top px</label>
							<span class=\"forminputdescription\">
								Margin Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_4_mtheme_margintop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_4][mtheme_margintop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_marginbottom\">Margin Bottom px</label>
							<span class=\"forminputdescription\">
								Margin Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_4_mtheme_marginbottom\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_4][mtheme_marginbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_width\">Width px</label>
							<span class=\"forminputdescription\">
								Width
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_4_mtheme_width\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_4][mtheme_width]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_link_url\">Link</label>
							<span class=\"forminputdescription\">
								Link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_4_mtheme_link_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_4][mtheme_link_url]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_link_type\">Open link in</label>
							<span class=\"forminputdescription\">
								Open link in
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_4_mtheme_link_type\" name=\"aq_blocks[aq_block_4][mtheme_link_type]\"><option value=\"_self\" selected=\"selected\">Same Tab</option><option value=\"_blank\">New Tab</option></select></div></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_image\">Image URL</label>
							<span class=\"forminputdescription\">
								Image URL
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://andresflower.com/wp-content/uploads/2019/06/badge-21-150x150.png\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_4_mtheme_image_imageid\" name=\"aq_blocks[aq_block_4][mtheme_imageid]\" value=\"9553\"><input type=\"text\" readonly=\"\" id=\"aq_block_4_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://andresflower.com/wp-content/uploads/2019/06/badge-21.png\" name=\"aq_blocks[aq_block_4][mtheme_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_4_mtheme_align\">Align image</label>
							<span class=\"forminputdescription\">
								Align image
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_4_mtheme_align\" name=\"aq_blocks[aq_block_4][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_4][id_base]\" value=\"em_singleimage\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_4][name]\" value=\"Single Image\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_4][order]\" value=\"1\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_4][size]\" value=\"span2\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_4][parent]\" value=\"3\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_4][number]\" value=\"4\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-5\" class=\"block block-em_singleimage span2 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-5\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"5\" data-mblocktype=\"em_singleimage\" 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(150,111,214,0.3) 0%, rgba(150,111,214,1) 100%);
background: -webkit-linear-gradient(left, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
background: linear-gradient(to right, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#966FD6a5\', endColorstr=\'#966FD6a5\',GradientType=1 );\"><i class=\"simpleicon-picture\"></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\">Single Image</div><div class=\"block-size\">2/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-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\">Single Image</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_5][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_5][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-5\">
						<div class=\"description mtheme-input-type-is-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\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_5_mtheme_animated\" name=\"aq_blocks[aq_block_5][mtheme_animated]\"><option value=\"none\" selected=\"selected\">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\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div></div><h3 class=\"group\">Spacing</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_paddingtop\">Top Space</label>
							<span class=\"forminputdescription\">
								Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_5_mtheme_paddingtop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_5][mtheme_paddingtop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_paddingbottom\">Bottom Space</label>
							<span class=\"forminputdescription\">
								Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">20</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">20</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">20</span></span><input type=\"text\" id=\"aq_block_5_mtheme_paddingbottom\" class=\"input-text-full responsive-data-text\" value=\"20\" name=\"aq_blocks[aq_block_5][mtheme_paddingbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_margintop\">Margin Top px</label>
							<span class=\"forminputdescription\">
								Margin Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_5_mtheme_margintop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_5][mtheme_margintop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_marginbottom\">Margin Bottom px</label>
							<span class=\"forminputdescription\">
								Margin Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_5_mtheme_marginbottom\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_5][mtheme_marginbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_width\">Width px</label>
							<span class=\"forminputdescription\">
								Width
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_5_mtheme_width\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_5][mtheme_width]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_link_url\">Link</label>
							<span class=\"forminputdescription\">
								Link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_5_mtheme_link_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_5][mtheme_link_url]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_link_type\">Open link in</label>
							<span class=\"forminputdescription\">
								Open link in
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_5_mtheme_link_type\" name=\"aq_blocks[aq_block_5][mtheme_link_type]\"><option value=\"_self\" selected=\"selected\">Same Tab</option><option value=\"_blank\">New Tab</option></select></div></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_image\">Image URL</label>
							<span class=\"forminputdescription\">
								Image URL
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://andresflower.com/wp-content/uploads/2019/06/badge-17-150x150.png\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_5_mtheme_image_imageid\" name=\"aq_blocks[aq_block_5][mtheme_imageid]\" value=\"9549\"><input type=\"text\" readonly=\"\" id=\"aq_block_5_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://andresflower.com/wp-content/uploads/2019/06/badge-17.png\" name=\"aq_blocks[aq_block_5][mtheme_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_5_mtheme_align\">Align image</label>
							<span class=\"forminputdescription\">
								Align image
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_5_mtheme_align\" name=\"aq_blocks[aq_block_5][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_5][id_base]\" value=\"em_singleimage\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_5][name]\" value=\"Single Image\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_5][order]\" value=\"2\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_5][size]\" value=\"span2\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_5][parent]\" value=\"3\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_5][number]\" value=\"5\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-6\" class=\"block block-em_singleimage span2 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-6\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"6\" data-mblocktype=\"em_singleimage\" 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(150,111,214,0.3) 0%, rgba(150,111,214,1) 100%);
background: -webkit-linear-gradient(left, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
background: linear-gradient(to right, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#966FD6a5\', endColorstr=\'#966FD6a5\',GradientType=1 );\"><i class=\"simpleicon-picture\"></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\">Single Image</div><div class=\"block-size\">2/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-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\">Single Image</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_6][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_6][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-6\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_6_mtheme_animated\" name=\"aq_blocks[aq_block_6][mtheme_animated]\"><option value=\"none\" selected=\"selected\">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\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div></div><h3 class=\"group\">Spacing</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_paddingtop\">Top Space</label>
							<span class=\"forminputdescription\">
								Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_6_mtheme_paddingtop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_6][mtheme_paddingtop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_paddingbottom\">Bottom Space</label>
							<span class=\"forminputdescription\">
								Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">20</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">20</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">20</span></span><input type=\"text\" id=\"aq_block_6_mtheme_paddingbottom\" class=\"input-text-full responsive-data-text\" value=\"20\" name=\"aq_blocks[aq_block_6][mtheme_paddingbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_margintop\">Margin Top px</label>
							<span class=\"forminputdescription\">
								Margin Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_6_mtheme_margintop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_6][mtheme_margintop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_marginbottom\">Margin Bottom px</label>
							<span class=\"forminputdescription\">
								Margin Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_6_mtheme_marginbottom\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_6][mtheme_marginbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_width\">Width px</label>
							<span class=\"forminputdescription\">
								Width
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_6_mtheme_width\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_6][mtheme_width]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_link_url\">Link</label>
							<span class=\"forminputdescription\">
								Link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_6_mtheme_link_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_6][mtheme_link_url]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_link_type\">Open link in</label>
							<span class=\"forminputdescription\">
								Open link in
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_6_mtheme_link_type\" name=\"aq_blocks[aq_block_6][mtheme_link_type]\"><option value=\"_self\" selected=\"selected\">Same Tab</option><option value=\"_blank\">New Tab</option></select></div></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_image\">Image URL</label>
							<span class=\"forminputdescription\">
								Image URL
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://andresflower.com/wp-content/uploads/2019/06/badge-16-150x150.png\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_6_mtheme_image_imageid\" name=\"aq_blocks[aq_block_6][mtheme_imageid]\" value=\"9548\"><input type=\"text\" readonly=\"\" id=\"aq_block_6_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://andresflower.com/wp-content/uploads/2019/06/badge-16.png\" name=\"aq_blocks[aq_block_6][mtheme_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_6_mtheme_align\">Align image</label>
							<span class=\"forminputdescription\">
								Align image
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_6_mtheme_align\" name=\"aq_blocks[aq_block_6][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_6][id_base]\" value=\"em_singleimage\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_6][name]\" value=\"Single Image\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_6][order]\" value=\"3\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_6][size]\" value=\"span2\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_6][parent]\" value=\"3\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_6][number]\" value=\"6\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-7\" class=\"block block-em_singleimage span2 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-7\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"7\" data-mblocktype=\"em_singleimage\" 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(150,111,214,0.3) 0%, rgba(150,111,214,1) 100%);
background: -webkit-linear-gradient(left, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
background: linear-gradient(to right, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#966FD6a5\', endColorstr=\'#966FD6a5\',GradientType=1 );\"><i class=\"simpleicon-picture\"></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\">Single Image</div><div class=\"block-size\">2/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-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\">Single Image</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_7][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_7][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-7\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_7_mtheme_animated\" name=\"aq_blocks[aq_block_7][mtheme_animated]\"><option value=\"none\" selected=\"selected\">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\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div></div><h3 class=\"group\">Spacing</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_paddingtop\">Top Space</label>
							<span class=\"forminputdescription\">
								Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_7_mtheme_paddingtop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_7][mtheme_paddingtop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_paddingbottom\">Bottom Space</label>
							<span class=\"forminputdescription\">
								Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">20</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">20</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">20</span></span><input type=\"text\" id=\"aq_block_7_mtheme_paddingbottom\" class=\"input-text-full responsive-data-text\" value=\"20\" name=\"aq_blocks[aq_block_7][mtheme_paddingbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_margintop\">Margin Top px</label>
							<span class=\"forminputdescription\">
								Margin Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_7_mtheme_margintop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_7][mtheme_margintop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_marginbottom\">Margin Bottom px</label>
							<span class=\"forminputdescription\">
								Margin Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_7_mtheme_marginbottom\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_7][mtheme_marginbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_width\">Width px</label>
							<span class=\"forminputdescription\">
								Width
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_7_mtheme_width\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_7][mtheme_width]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_link_url\">Link</label>
							<span class=\"forminputdescription\">
								Link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_7_mtheme_link_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_7][mtheme_link_url]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_link_type\">Open link in</label>
							<span class=\"forminputdescription\">
								Open link in
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_7_mtheme_link_type\" name=\"aq_blocks[aq_block_7][mtheme_link_type]\"><option value=\"_self\" selected=\"selected\">Same Tab</option><option value=\"_blank\">New Tab</option></select></div></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_image\">Image URL</label>
							<span class=\"forminputdescription\">
								Image URL
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://andresflower.com/wp-content/uploads/2020/02/badge-27-150x150.png\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_7_mtheme_image_imageid\" name=\"aq_blocks[aq_block_7][mtheme_imageid]\" value=\"12372\"><input type=\"text\" readonly=\"\" id=\"aq_block_7_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://andresflower.com/wp-content/uploads/2020/02/badge-27.png\" name=\"aq_blocks[aq_block_7][mtheme_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_7_mtheme_align\">Align image</label>
							<span class=\"forminputdescription\">
								Align image
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_7_mtheme_align\" name=\"aq_blocks[aq_block_7][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_7][id_base]\" value=\"em_singleimage\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_7][name]\" value=\"Single Image\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_7][order]\" value=\"4\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_7][size]\" value=\"span2\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_7][parent]\" value=\"3\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_7][number]\" value=\"7\">				</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_singleimage span2 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-8\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"8\" data-mblocktype=\"em_singleimage\" 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(150,111,214,0.3) 0%, rgba(150,111,214,1) 100%);
background: -webkit-linear-gradient(left, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
background: linear-gradient(to right, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#966FD6a5\', endColorstr=\'#966FD6a5\',GradientType=1 );\"><i class=\"simpleicon-picture\"></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\">Single Image</div><div class=\"block-size\">2/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-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\">Single Image</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_8][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_8][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-8\">
						<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\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_8_mtheme_animated\" name=\"aq_blocks[aq_block_8][mtheme_animated]\"><option value=\"none\" selected=\"selected\">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\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div></div><h3 class=\"group\">Spacing</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_paddingtop\">Top Space</label>
							<span class=\"forminputdescription\">
								Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_8_mtheme_paddingtop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_8][mtheme_paddingtop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_paddingbottom\">Bottom Space</label>
							<span class=\"forminputdescription\">
								Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">20</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">20</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">20</span></span><input type=\"text\" id=\"aq_block_8_mtheme_paddingbottom\" class=\"input-text-full responsive-data-text\" value=\"20\" name=\"aq_blocks[aq_block_8][mtheme_paddingbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_margintop\">Margin Top px</label>
							<span class=\"forminputdescription\">
								Margin Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_8_mtheme_margintop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_8][mtheme_margintop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_marginbottom\">Margin Bottom px</label>
							<span class=\"forminputdescription\">
								Margin Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_8_mtheme_marginbottom\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_8][mtheme_marginbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_width\">Width px</label>
							<span class=\"forminputdescription\">
								Width
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_8_mtheme_width\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_8][mtheme_width]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_link_url\">Link</label>
							<span class=\"forminputdescription\">
								Link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_8_mtheme_link_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_8][mtheme_link_url]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_link_type\">Open link in</label>
							<span class=\"forminputdescription\">
								Open link in
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_8_mtheme_link_type\" name=\"aq_blocks[aq_block_8][mtheme_link_type]\"><option value=\"_self\" selected=\"selected\">Same Tab</option><option value=\"_blank\">New Tab</option></select></div></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_image\">Image URL</label>
							<span class=\"forminputdescription\">
								Image URL
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://andresflower.com/wp-content/uploads/2020/02/badge-28-150x150.png\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_8_mtheme_image_imageid\" name=\"aq_blocks[aq_block_8][mtheme_imageid]\" value=\"12373\"><input type=\"text\" readonly=\"\" id=\"aq_block_8_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://andresflower.com/wp-content/uploads/2020/02/badge-28.png\" name=\"aq_blocks[aq_block_8][mtheme_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_8_mtheme_align\">Align image</label>
							<span class=\"forminputdescription\">
								Align image
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_8_mtheme_align\" name=\"aq_blocks[aq_block_8][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_8][id_base]\" value=\"em_singleimage\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_8][name]\" value=\"Single Image\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_8][order]\" value=\"5\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_8][size]\" value=\"span2\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_8][parent]\" value=\"3\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_8][number]\" value=\"8\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-9\" class=\"block block-em_singleimage span2 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-9\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"9\" data-mblocktype=\"em_singleimage\" 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(150,111,214,0.3) 0%, rgba(150,111,214,1) 100%);
background: -webkit-linear-gradient(left, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
background: linear-gradient(to right, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#966FD6a5\', endColorstr=\'#966FD6a5\',GradientType=1 );\"><i class=\"simpleicon-picture\"></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\">Single Image</div><div class=\"block-size\">2/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-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\">Single Image</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_9][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_9][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-9\">
						<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\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_9_mtheme_animated\" name=\"aq_blocks[aq_block_9][mtheme_animated]\"><option value=\"none\" selected=\"selected\">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\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div></div><h3 class=\"group\">Spacing</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_paddingtop\">Top Space</label>
							<span class=\"forminputdescription\">
								Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_9_mtheme_paddingtop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_9][mtheme_paddingtop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_paddingbottom\">Bottom Space</label>
							<span class=\"forminputdescription\">
								Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">20</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">20</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">20</span></span><input type=\"text\" id=\"aq_block_9_mtheme_paddingbottom\" class=\"input-text-full responsive-data-text\" value=\"20\" name=\"aq_blocks[aq_block_9][mtheme_paddingbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_margintop\">Margin Top px</label>
							<span class=\"forminputdescription\">
								Margin Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_9_mtheme_margintop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_9][mtheme_margintop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_marginbottom\">Margin Bottom px</label>
							<span class=\"forminputdescription\">
								Margin Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_9_mtheme_marginbottom\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_9][mtheme_marginbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_width\">Width px</label>
							<span class=\"forminputdescription\">
								Width
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_9_mtheme_width\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_9][mtheme_width]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_link_url\">Link</label>
							<span class=\"forminputdescription\">
								Link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_9_mtheme_link_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_9][mtheme_link_url]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_link_type\">Open link in</label>
							<span class=\"forminputdescription\">
								Open link in
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_9_mtheme_link_type\" name=\"aq_blocks[aq_block_9][mtheme_link_type]\"><option value=\"_self\" selected=\"selected\">Same Tab</option><option value=\"_blank\">New Tab</option></select></div></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_image\">Image URL</label>
							<span class=\"forminputdescription\">
								Image URL
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://andresflower.com/wp-content/uploads/2020/02/badge-29-150x150.png\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_9_mtheme_image_imageid\" name=\"aq_blocks[aq_block_9][mtheme_imageid]\" value=\"12374\"><input type=\"text\" readonly=\"\" id=\"aq_block_9_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://andresflower.com/wp-content/uploads/2020/02/badge-29.png\" name=\"aq_blocks[aq_block_9][mtheme_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_9_mtheme_align\">Align image</label>
							<span class=\"forminputdescription\">
								Align image
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_9_mtheme_align\" name=\"aq_blocks[aq_block_9][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_9][id_base]\" value=\"em_singleimage\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_9][name]\" value=\"Single Image\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_9][order]\" value=\"6\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_9][size]\" value=\"span2\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_9][parent]\" value=\"3\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_9][number]\" value=\"9\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-10\" class=\"block block-em_singleimage span2 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-10\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"10\" data-mblocktype=\"em_singleimage\" 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(150,111,214,0.3) 0%, rgba(150,111,214,1) 100%);
background: -webkit-linear-gradient(left, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
background: linear-gradient(to right, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#966FD6a5\', endColorstr=\'#966FD6a5\',GradientType=1 );\"><i class=\"simpleicon-picture\"></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\">Single Image</div><div class=\"block-size\">2/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-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\">Single Image</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_10][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_10][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-10\">
						<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\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_10_mtheme_animated\" name=\"aq_blocks[aq_block_10][mtheme_animated]\"><option value=\"none\" selected=\"selected\">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\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div></div><h3 class=\"group\">Spacing</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_paddingtop\">Top Space</label>
							<span class=\"forminputdescription\">
								Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_10_mtheme_paddingtop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_10][mtheme_paddingtop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_paddingbottom\">Bottom Space</label>
							<span class=\"forminputdescription\">
								Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">20</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">20</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">20</span></span><input type=\"text\" id=\"aq_block_10_mtheme_paddingbottom\" class=\"input-text-full responsive-data-text\" value=\"20\" name=\"aq_blocks[aq_block_10][mtheme_paddingbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_margintop\">Margin Top px</label>
							<span class=\"forminputdescription\">
								Margin Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_10_mtheme_margintop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_10][mtheme_margintop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_marginbottom\">Margin Bottom px</label>
							<span class=\"forminputdescription\">
								Margin Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_10_mtheme_marginbottom\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_10][mtheme_marginbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_width\">Width px</label>
							<span class=\"forminputdescription\">
								Width
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_10_mtheme_width\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_10][mtheme_width]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_link_url\">Link</label>
							<span class=\"forminputdescription\">
								Link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_10_mtheme_link_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_10][mtheme_link_url]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_link_type\">Open link in</label>
							<span class=\"forminputdescription\">
								Open link in
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_10_mtheme_link_type\" name=\"aq_blocks[aq_block_10][mtheme_link_type]\"><option value=\"_self\" selected=\"selected\">Same Tab</option><option value=\"_blank\">New Tab</option></select></div></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_image\">Image URL</label>
							<span class=\"forminputdescription\">
								Image URL
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://andresflower.com/wp-content/uploads/2019/06/badge-13-150x150.png\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_10_mtheme_image_imageid\" name=\"aq_blocks[aq_block_10][mtheme_imageid]\" value=\"9545\"><input type=\"text\" readonly=\"\" id=\"aq_block_10_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://andresflower.com/wp-content/uploads/2019/06/badge-13.png\" name=\"aq_blocks[aq_block_10][mtheme_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_10_mtheme_align\">Align image</label>
							<span class=\"forminputdescription\">
								Align image
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_10_mtheme_align\" name=\"aq_blocks[aq_block_10][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_10][id_base]\" value=\"em_singleimage\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_10][name]\" value=\"Single Image\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_10][order]\" value=\"7\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_10][size]\" value=\"span2\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_10][parent]\" value=\"3\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_10][number]\" value=\"10\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-11\" class=\"block block-em_singleimage span2 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-11\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"11\" data-mblocktype=\"em_singleimage\" 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(150,111,214,0.3) 0%, rgba(150,111,214,1) 100%);
background: -webkit-linear-gradient(left, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
background: linear-gradient(to right, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#966FD6a5\', endColorstr=\'#966FD6a5\',GradientType=1 );\"><i class=\"simpleicon-picture\"></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\">Single Image</div><div class=\"block-size\">2/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-11\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Single Image</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_11][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_11][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-11\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_11_mtheme_animated\" name=\"aq_blocks[aq_block_11][mtheme_animated]\"><option value=\"none\" selected=\"selected\">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\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div></div><h3 class=\"group\">Spacing</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_paddingtop\">Top Space</label>
							<span class=\"forminputdescription\">
								Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_11_mtheme_paddingtop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_11][mtheme_paddingtop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_paddingbottom\">Bottom Space</label>
							<span class=\"forminputdescription\">
								Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">20</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">20</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">20</span></span><input type=\"text\" id=\"aq_block_11_mtheme_paddingbottom\" class=\"input-text-full responsive-data-text\" value=\"20\" name=\"aq_blocks[aq_block_11][mtheme_paddingbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_margintop\">Margin Top px</label>
							<span class=\"forminputdescription\">
								Margin Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_11_mtheme_margintop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_11][mtheme_margintop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_marginbottom\">Margin Bottom px</label>
							<span class=\"forminputdescription\">
								Margin Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_11_mtheme_marginbottom\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_11][mtheme_marginbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_width\">Width px</label>
							<span class=\"forminputdescription\">
								Width
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_11_mtheme_width\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_11][mtheme_width]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_link_url\">Link</label>
							<span class=\"forminputdescription\">
								Link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_11_mtheme_link_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_11][mtheme_link_url]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_link_type\">Open link in</label>
							<span class=\"forminputdescription\">
								Open link in
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_11_mtheme_link_type\" name=\"aq_blocks[aq_block_11][mtheme_link_type]\"><option value=\"_self\" selected=\"selected\">Same Tab</option><option value=\"_blank\">New Tab</option></select></div></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_image\">Image URL</label>
							<span class=\"forminputdescription\">
								Image URL
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://andresflower.com/wp-content/uploads/2020/02/badge-33-150x150.png\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_11_mtheme_image_imageid\" name=\"aq_blocks[aq_block_11][mtheme_imageid]\" value=\"12378\"><input type=\"text\" readonly=\"\" id=\"aq_block_11_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://andresflower.com/wp-content/uploads/2020/02/badge-33.png\" name=\"aq_blocks[aq_block_11][mtheme_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_11_mtheme_align\">Align image</label>
							<span class=\"forminputdescription\">
								Align image
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_11_mtheme_align\" name=\"aq_blocks[aq_block_11][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_11][id_base]\" value=\"em_singleimage\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_11][name]\" value=\"Single Image\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_11][order]\" value=\"8\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_11][size]\" value=\"span2\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_11][parent]\" value=\"3\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_11][number]\" value=\"11\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-12\" class=\"block block-em_singleimage span2 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-12\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"12\" data-mblocktype=\"em_singleimage\" 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(150,111,214,0.3) 0%, rgba(150,111,214,1) 100%);
background: -webkit-linear-gradient(left, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
background: linear-gradient(to right, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#966FD6a5\', endColorstr=\'#966FD6a5\',GradientType=1 );\"><i class=\"simpleicon-picture\"></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\">Single Image</div><div class=\"block-size\">2/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-12\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Single Image</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_12][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_12][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-12\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_12_mtheme_animated\" name=\"aq_blocks[aq_block_12][mtheme_animated]\"><option value=\"none\" selected=\"selected\">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\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div></div><h3 class=\"group\">Spacing</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_paddingtop\">Top Space</label>
							<span class=\"forminputdescription\">
								Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_12_mtheme_paddingtop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_12][mtheme_paddingtop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_paddingbottom\">Bottom Space</label>
							<span class=\"forminputdescription\">
								Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">20</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">20</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">20</span></span><input type=\"text\" id=\"aq_block_12_mtheme_paddingbottom\" class=\"input-text-full responsive-data-text\" value=\"20\" name=\"aq_blocks[aq_block_12][mtheme_paddingbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_margintop\">Margin Top px</label>
							<span class=\"forminputdescription\">
								Margin Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_12_mtheme_margintop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_12][mtheme_margintop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_marginbottom\">Margin Bottom px</label>
							<span class=\"forminputdescription\">
								Margin Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_12_mtheme_marginbottom\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_12][mtheme_marginbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_width\">Width px</label>
							<span class=\"forminputdescription\">
								Width
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_12_mtheme_width\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_12][mtheme_width]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_link_url\">Link</label>
							<span class=\"forminputdescription\">
								Link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_12_mtheme_link_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_12][mtheme_link_url]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_link_type\">Open link in</label>
							<span class=\"forminputdescription\">
								Open link in
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_12_mtheme_link_type\" name=\"aq_blocks[aq_block_12][mtheme_link_type]\"><option value=\"_self\" selected=\"selected\">Same Tab</option><option value=\"_blank\">New Tab</option></select></div></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_image\">Image URL</label>
							<span class=\"forminputdescription\">
								Image URL
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://andresflower.com/wp-content/uploads/2020/02/badge-30-150x150.png\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_12_mtheme_image_imageid\" name=\"aq_blocks[aq_block_12][mtheme_imageid]\" value=\"12375\"><input type=\"text\" readonly=\"\" id=\"aq_block_12_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://andresflower.com/wp-content/uploads/2020/02/badge-30.png\" name=\"aq_blocks[aq_block_12][mtheme_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_12_mtheme_align\">Align image</label>
							<span class=\"forminputdescription\">
								Align image
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_12_mtheme_align\" name=\"aq_blocks[aq_block_12][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_12][id_base]\" value=\"em_singleimage\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_12][name]\" value=\"Single Image\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_12][order]\" value=\"9\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_12][size]\" value=\"span2\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_12][parent]\" value=\"3\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_12][number]\" value=\"12\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-13\" class=\"block block-em_singleimage span2 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-13\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"13\" data-mblocktype=\"em_singleimage\" 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(150,111,214,0.3) 0%, rgba(150,111,214,1) 100%);
background: -webkit-linear-gradient(left, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
background: linear-gradient(to right, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#966FD6a5\', endColorstr=\'#966FD6a5\',GradientType=1 );\"><i class=\"simpleicon-picture\"></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\">Single Image</div><div class=\"block-size\">2/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-13\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Single Image</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_13][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_13][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-13\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_13_mtheme_animated\" name=\"aq_blocks[aq_block_13][mtheme_animated]\"><option value=\"none\" selected=\"selected\">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\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div></div><h3 class=\"group\">Spacing</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_mtheme_paddingtop\">Top Space</label>
							<span class=\"forminputdescription\">
								Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_13_mtheme_paddingtop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_13][mtheme_paddingtop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_mtheme_paddingbottom\">Bottom Space</label>
							<span class=\"forminputdescription\">
								Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">20</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">20</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">20</span></span><input type=\"text\" id=\"aq_block_13_mtheme_paddingbottom\" class=\"input-text-full responsive-data-text\" value=\"20\" name=\"aq_blocks[aq_block_13][mtheme_paddingbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_mtheme_margintop\">Margin Top px</label>
							<span class=\"forminputdescription\">
								Margin Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_13_mtheme_margintop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_13][mtheme_margintop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_mtheme_marginbottom\">Margin Bottom px</label>
							<span class=\"forminputdescription\">
								Margin Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_13_mtheme_marginbottom\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_13][mtheme_marginbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_mtheme_width\">Width px</label>
							<span class=\"forminputdescription\">
								Width
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_13_mtheme_width\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_13][mtheme_width]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_mtheme_link_url\">Link</label>
							<span class=\"forminputdescription\">
								Link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_13_mtheme_link_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][mtheme_link_url]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_mtheme_link_type\">Open link in</label>
							<span class=\"forminputdescription\">
								Open link in
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_13_mtheme_link_type\" name=\"aq_blocks[aq_block_13][mtheme_link_type]\"><option value=\"_self\" selected=\"selected\">Same Tab</option><option value=\"_blank\">New Tab</option></select></div></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_mtheme_image\">Image URL</label>
							<span class=\"forminputdescription\">
								Image URL
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://andresflower.com/wp-content/uploads/2020/02/badge-31-150x150.png\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_13_mtheme_image_imageid\" name=\"aq_blocks[aq_block_13][mtheme_imageid]\" value=\"12376\"><input type=\"text\" readonly=\"\" id=\"aq_block_13_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://andresflower.com/wp-content/uploads/2020/02/badge-31.png\" name=\"aq_blocks[aq_block_13][mtheme_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_mtheme_align\">Align image</label>
							<span class=\"forminputdescription\">
								Align image
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_13_mtheme_align\" name=\"aq_blocks[aq_block_13][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_13][id_base]\" value=\"em_singleimage\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_13][name]\" value=\"Single Image\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_13][order]\" value=\"10\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_13][size]\" value=\"span2\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_13][parent]\" value=\"3\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_13][number]\" value=\"13\">				</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-14\" class=\"block block-em_singleimage span2 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-14\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"14\" data-mblocktype=\"em_singleimage\" 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(150,111,214,0.3) 0%, rgba(150,111,214,1) 100%);
background: -webkit-linear-gradient(left, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
background: linear-gradient(to right, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#966FD6a5\', endColorstr=\'#966FD6a5\',GradientType=1 );\"><i class=\"simpleicon-picture\"></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\">Single Image</div><div class=\"block-size\">2/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-14\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Single Image</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_14][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_14][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-14\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_14_mtheme_animated\" name=\"aq_blocks[aq_block_14][mtheme_animated]\"><option value=\"none\" selected=\"selected\">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\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div></div><h3 class=\"group\">Spacing</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_paddingtop\">Top Space</label>
							<span class=\"forminputdescription\">
								Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_14_mtheme_paddingtop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_14][mtheme_paddingtop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_paddingbottom\">Bottom Space</label>
							<span class=\"forminputdescription\">
								Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">20</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">20</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">20</span></span><input type=\"text\" id=\"aq_block_14_mtheme_paddingbottom\" class=\"input-text-full responsive-data-text\" value=\"20\" name=\"aq_blocks[aq_block_14][mtheme_paddingbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_margintop\">Margin Top px</label>
							<span class=\"forminputdescription\">
								Margin Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_14_mtheme_margintop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_14][mtheme_margintop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_marginbottom\">Margin Bottom px</label>
							<span class=\"forminputdescription\">
								Margin Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_14_mtheme_marginbottom\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_14][mtheme_marginbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_width\">Width px</label>
							<span class=\"forminputdescription\">
								Width
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_14_mtheme_width\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_width]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_link_url\">Link</label>
							<span class=\"forminputdescription\">
								Link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_14_mtheme_link_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_link_url]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_link_type\">Open link in</label>
							<span class=\"forminputdescription\">
								Open link in
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_14_mtheme_link_type\" name=\"aq_blocks[aq_block_14][mtheme_link_type]\"><option value=\"_self\" selected=\"selected\">Same Tab</option><option value=\"_blank\">New Tab</option></select></div></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_image\">Image URL</label>
							<span class=\"forminputdescription\">
								Image URL
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://andresflower.com/wp-content/uploads/2020/02/badge-32-150x150.png\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_14_mtheme_image_imageid\" name=\"aq_blocks[aq_block_14][mtheme_imageid]\" value=\"12377\"><input type=\"text\" readonly=\"\" id=\"aq_block_14_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://andresflower.com/wp-content/uploads/2020/02/badge-32.png\" name=\"aq_blocks[aq_block_14][mtheme_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_align\">Align image</label>
							<span class=\"forminputdescription\">
								Align image
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_14_mtheme_align\" name=\"aq_blocks[aq_block_14][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_14][id_base]\" value=\"em_singleimage\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_14][name]\" value=\"Single Image\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_14][order]\" value=\"11\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_14][size]\" value=\"span2\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_14][parent]\" value=\"3\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_14][number]\" value=\"14\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-15\" class=\"block block-em_singleimage span2 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-15\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"15\" data-mblocktype=\"em_singleimage\" 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(150,111,214,0.3) 0%, rgba(150,111,214,1) 100%);
background: -webkit-linear-gradient(left, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
background: linear-gradient(to right, rgba(150,111,214,0.5) 0%,rgba(150,111,214,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#966FD6a5\', endColorstr=\'#966FD6a5\',GradientType=1 );\"><i class=\"simpleicon-picture\"></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\">Single Image</div><div class=\"block-size\">2/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-15\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Single Image</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_15][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_15][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-15\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_15_mtheme_animated\" name=\"aq_blocks[aq_block_15][mtheme_animated]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"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\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option></select></div></div></div><h3 class=\"group\">Spacing</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_paddingtop\">Top Space</label>
							<span class=\"forminputdescription\">
								Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_15_mtheme_paddingtop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_15][mtheme_paddingtop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_paddingbottom\">Bottom Space</label>
							<span class=\"forminputdescription\">
								Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">20</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">20</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">20</span></span><input type=\"text\" id=\"aq_block_15_mtheme_paddingbottom\" class=\"input-text-full responsive-data-text\" value=\"20\" name=\"aq_blocks[aq_block_15][mtheme_paddingbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_margintop\">Margin Top px</label>
							<span class=\"forminputdescription\">
								Margin Top Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_15_mtheme_margintop\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_15][mtheme_margintop]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_marginbottom\">Margin Bottom px</label>
							<span class=\"forminputdescription\">
								Margin Bottom Space
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_15_mtheme_marginbottom\" class=\"input-text-full responsive-data-text\" value=\"0\" name=\"aq_blocks[aq_block_15][mtheme_marginbottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_width\">Width px</label>
							<span class=\"forminputdescription\">
								Width
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_15_mtheme_width\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_15][mtheme_width]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_link_url\">Link</label>
							<span class=\"forminputdescription\">
								Link
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_15_mtheme_link_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_15][mtheme_link_url]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_link_type\">Open link in</label>
							<span class=\"forminputdescription\">
								Open link in
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_15_mtheme_link_type\" name=\"aq_blocks[aq_block_15][mtheme_link_type]\"><option value=\"_self\" selected=\"selected\">Same Tab</option><option value=\"_blank\">New Tab</option></select></div></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_image\">Image URL</label>
							<span class=\"forminputdescription\">
								Image URL
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"http://andresflower.com/wp-content/uploads/2020/02/badge-34-150x150.png\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_15_mtheme_image_imageid\" name=\"aq_blocks[aq_block_15][mtheme_imageid]\" value=\"12379\"><input type=\"text\" readonly=\"\" id=\"aq_block_15_mtheme_image\" class=\"input-full imagefile-uploader\" value=\"http://andresflower.com/wp-content/uploads/2020/02/badge-34.png\" name=\"aq_blocks[aq_block_15][mtheme_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_align\">Align image</label>
							<span class=\"forminputdescription\">
								Align image
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_15_mtheme_align\" name=\"aq_blocks[aq_block_15][mtheme_align]\"><option value=\"left\">Left</option><option value=\"center\" selected=\"selected\">Center</option><option value=\"right\">Right</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_15][id_base]\" value=\"em_singleimage\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_15][name]\" value=\"Single Image\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_15][order]\" value=\"12\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_15][size]\" value=\"span2\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_15][parent]\" value=\"3\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_15][number]\" value=\"15\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li></ul><div id=\"my-column-content-3\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" type=\"text\" name=\"aq_blocks[aq_block_3][blockID]\" value=\"\" id=\"blockID\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" type=\"text\" name=\"aq_blocks[aq_block_3][blockNote]\" value=\"\" id=\"blockNote\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_container_type\">Boxed or Fullwidth</label>
							<span class=\"forminputdescription\">
								Boxed or Fullwidth. For full columns
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_3_container_type\" name=\"aq_blocks[aq_block_3][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_3_text_intensity\" name=\"aq_blocks[aq_block_3][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></div></div></div><h3 class=\"group\">Margin</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_margin_top\">Margin top in pixels</label>
							<span class=\"forminputdescription\">
								Margin top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_3_margin_top\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_3][margin_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"forminputdescription\">
								Margin bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_3_margin_bottom\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_3][margin_bottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><h3 class=\"group\">Padding</h3><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_padding_top\">Padding top in pixels</label>
							<span class=\"forminputdescription\">
								Padding top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_3_padding_top\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_3][padding_top]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"forminputdescription\">
								Padding bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_3_padding_bottom\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_3][padding_bottom]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_padding_sides\">Padding sides in pixels</label>
							<span class=\"forminputdescription\">
								Padding sides in pixels
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_3_padding_sides\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_3][padding_sides]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_padding_sidespercent\">Padding sides % ( in percentage )</label>
							<span class=\"forminputdescription\">
								Padding both sides in percentage value
							</span>
						</div><div class=\"formview-rightside text\"><span class=\"responsive-data-media\"><i class=\"dashicons-before dashicons-desktop\"></i><span title=\"Desktop\" class=\"responsive-data-fields responsive-data-desktop\">0</span><i class=\"dashicons-before dashicons-tablet\"></i><span title=\"Tablet\" class=\"responsive-data-fields responsive-data-tablet\">0</span><i class=\"dashicons-before dashicons-smartphone\"></i><span title=\"Mobile\" class=\"responsive-data-fields responsive-data-mobile\">0</span></span><input type=\"text\" id=\"aq_block_3_padding_sidespercent\" class=\"input-text-full responsive-data-text\" value=\"\" name=\"aq_blocks[aq_block_3][padding_sidespercent]\"><span class=\"field-helper\">Comma separated values for responsiveness ( eg. 30,20,15 )</span></div></div><h3 class=\"group\">Background Color</h3><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Elegir color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Valor del color</span><input type=\"text\" id=\"aq_block_3_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_3][background_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Borrar\" aria-label=\"Borrar color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_gradient_color\">Combine with background color to create Gradients</label>
							<span class=\"forminputdescription\">
								Apply Gradient color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Elegir color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Valor del color</span><input type=\"text\" id=\"aq_block_3_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_3][gradient_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Borrar\" aria-label=\"Borrar color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-slider-vertical ui-widget ui-widget-content ui-corner-all\"><span class=\"ui-slider-handle ui-state-default ui-corner-all\" tabindex=\"0\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_3_gradient_angle\" name=\"aq_blocks[aq_block_3][gradient_angle]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"to_bottom\">to bottom</option><option value=\"to_top\">to top</option><option value=\"to_top_right\">to top right</option><option value=\"to_top_left\">to top left</option><option value=\"to_bottom_right\">to bottom right</option><option value=\"to_bottom_left\">to bottom left</option></select></div></div></div><h3 class=\"group\">Background Image</h3><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_background_image\">Background Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_3_background_image_imageid\" name=\"aq_blocks[aq_block_3][background_imageid]\" value=\"\"><input type=\"text\" readonly=\"\" id=\"aq_block_3_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_3][background_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_background_scroll\">Scroll effect</label>
							<span class=\"forminputdescription\">
								Scroll effect
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_3_background_scroll\" name=\"aq_blocks[aq_block_3][background_scroll]\"><option value=\"parallax\" selected=\"selected\">Parallax</option><option value=\"static\">Static</option></select></div></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_3_background_position\">Background Position ( Non Parallax )</label>
							<span class=\"forminputdescription\">
								Background Position ( Non Parallax )
							</span>
						</div><div class=\"formview-rightside select\"><div class=\"select-parent-wrap\"><select class=\"select-parent select-choice\" id=\"aq_block_3_background_position\" name=\"aq_blocks[aq_block_3][background_position]\"><option value=\"none\" selected=\"selected\">None</option><option value=\"top_left\">Top Left</option><option value=\"top_center\">Top Center</option><option value=\"top_right\">Top Right</option><option value=\"center_left\">Center Left</option><option value=\"center\">Center</option><option value=\"center_right\">Center Right</option><option value=\"bottom_left\">Bottom Left</option><option value=\"bottom_center\">Bottom Center</option><option value=\"bottom_right\">Bottom Right</option></select></div></div></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_3][id_base]\" value=\"em_column_block\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_3][name]\" value=\"Column Container\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_3][order]\" value=\"3\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_3][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_3][parent]\" value=\"0\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_3][number]\" value=\"3\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>
Sin categoría