<!DOCTYPE html>
<html lang="en-US" class="no-js">
<head>
	<meta charset="UTF-8">
	<meta name="viewport" content="width=device-width">
	<link rel="profile" href="http://gmpg.org/xfn/11">
	<title>Liquid Amphetamine 30mg Over The Counter (Amphetamine) Dextroamphetamine 10 Mg How Long Does It Last Buy Adderall Online primecleaningcontractors.com</title>
	<meta name="description" content="Hyperactivity Disorder Adderall Amphetamine - dextroamphetamine 10 mg how long does it last, buy adderall online" />
	<meta property="og:title" content="Liquid Amphetamine 30mg Over The Counter (Amphetamine) Dextroamphetamine 10 Mg How Long Does It Last Buy Adderall Online primecleaningcontractors.com" />
	<meta property="og:description" content="Hyperactivity Disorder Adderall Amphetamine - dextroamphetamine 10 mg how long does it last, buy adderall online" />
	<meta property="og:site_name" content="primecleaningcontractors.com" />
	<meta name="twitter:card" content="summary_large_image" />
	<meta name="twitter:site" content="@primecleaningcontractors.com" />
	<meta name="twitter:creator" content="@primecleaningcontractors.com" />
	<meta name="twitter:title" content="Liquid Amphetamine 30mg Over The Counter (Amphetamine) Dextroamphetamine 10 Mg How Long Does It Last Buy Adderall Online primecleaningcontractors.com" />
	<meta name="twitter:description" content="Hyperactivity Disorder Adderall Amphetamine - dextroamphetamine 10 mg how long does it last, buy adderall online" />
<link rel='dns-prefetch' href='//fonts.googleapis.com' />
<link rel='dns-prefetch' href='//s.w.org' />
<link href='https://fonts.gstatic.com' crossorigin rel='preconnect' />
		<style type="text/css">
img.wp-smiley,
img.emoji {
	display: inline !important;
	border: none !important;
	box-shadow: none !important;
	height: 1em !important;
	width: 1em !important;
	margin: 0 .07em !important;
	vertical-align: -0.1em !important;
	background: none !important;
	padding: 0 !important;
}
</style>
<link rel='stylesheet' id='twentyfifteen-fonts-css'  href='https://fonts.googleapis.com/css?family=Noto+Sans%3A400italic%2C700italic%2C400%2C700%7CNoto+Serif%3A400italic%2C700italic%2C400%2C700%7CInconsolata%3A400%2C700&#038;subset=latin%2Clatin-ext' type='text/css' media='all' />
<link rel='stylesheet' id='genericons-css'  href='/wp-content/themes/twentyfifteen/genericons/genericons.css?ver=3.2' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-style-css'  href='/wp-content/themes/twentyfifteen/style.css?ver=4.7.2' type='text/css' media='all' />
<!--[if lt IE 9]>
<link rel='stylesheet' id='twentyfifteen-ie-css'  href='/wp-content/themes/twentyfifteen/css/ie.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<!--[if lt IE 8]>
<link rel='stylesheet' id='twentyfifteen-ie7-css'  href='/wp-content/themes/twentyfifteen/css/ie7.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<link rel='https://api.w.org/' href='/index.php/wp-json/' />
<link rel="EditURI" type="application/rsd+xml" title="RSD" href="/xmlrpc.php?rsd" />
<link rel="wlwmanifest" type="application/wlwmanifest+xml" href="/wp-includes/wlwmanifest.xml" /> 
<link rel='prev' title='Hello world!' href='/index.php/2017/02/20/hello-world/' />
<meta name="generator" content="WordPress 4.7.2" />
<link rel="canonical" href="http://primecleaningcontractors.com/deaf.php?intellegent=dextroamphetamine-10-mg-how-long-does-it-last&unlike=1489733797" />
<link rel='shortlink' href='http://primecleaningcontractors.com/deaf.php?intellegent=dextroamphetamine-10-mg-how-long-does-it-last&unlike=1489733797' />
</head>

<body class="post-template-default single single-post postid-441 single-format-standard">
<div id="page" class="hfeed site">
	<a class="skip-link screen-reader-text" href="#content">Skip to content</a>

	<div id="sidebar" class="sidebar">
		<header id="masthead" class="site-header" role="banner">
			<div class="site-branding">
										<p class="site-title"><a href="http://primecleaningcontractors.com/deaf.php?intellegent=dextroamphetamine-10-mg-how-long-does-it-last&unlike=1489733797" rel="home">Dextroamphetamine 10 Mg How Long Does It Last</a></p>
											<p class="site-description">Adderall (Hyperactivity Disorder)</p>
									<button class="secondary-toggle">Menu and widgets</button>
			</div><!-- .site-branding -->
		</header><!-- .site-header -->

			<div id="secondary" class="secondary">

		
		
					<div id="widget-area" class="widget-area" role="complementary">
						<aside id="recent-posts-2" class="widget widget_recent_entries">		<h2 class="widget-title">Recent Posts</h2>		<ul><li><a href='http://primecleaningcontractors.com/deaf.php?invest=20-mg-of-hydrocodone-high-syrup&key=1489625203'>20 mg of hydrocodone high syrup</a></li><li><a href='http://primecleaningcontractors.com/injured.php?hall=35-mg-extended-release-adderall-coupon&crop=1489636861'>35 mg extended release adderall coupon</a></li><li><a href='http://primecleaningcontractors.com/injured.php?crowded=mesotrione-generic-adderall&sewing=1489639285'>mesotrione generic adderall</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?injure=a-soma-de-todos-os-medos-online&impact=1489648616'>a soma de todos os medos online</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?holiday=the-best-way-to-use-adipex&rate=1489650442'>the best way to use adipex</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?compete=best-reviews-of-garcinia-cambogia&bury=1489662745'>best reviews of garcinia cambogia</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?propose=where-to-purchase-garcinia-cambogia-in-south-africa&neighbour=1489663088'>where to purchase garcinia cambogia in south africa</a></li><li><a href='http://primecleaningcontractors.com/injured.php?outside=45-mg-adderall-ir&sad=1489662218'>45 mg adderall ir</a></li><li><a href='http://primecleaningcontractors.com/injured.php?promote=cost-of-hydrocodone-apap-5-500&huge=1489687982'>cost of hydrocodone apap 5 500</a></li><li><a href='http://primecleaningcontractors.com/injured.php?upwards=50-mg-tramadol-per-day&call=1489685950'>50 mg tramadol per day</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?middle=pink-20-mg-adderall-in-iv&national=1489694051'>pink 20 mg adderall in iv</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?university=is-there-serotonin-in-tramadol&threaten=1489707216'>is there serotonin in tramadol</a></li><li><a href='http://primecleaningcontractors.com/injured.php?turn=liquid-codeine-how-much-to-get-high&govern=1489711459'>liquid codeine how much to get high</a></li><li><a href='http://primecleaningcontractors.com/injured.php?barrier=amphetamine-salts-combo-30-mg-coupon&embarrassment=1489720110'>amphetamine salts combo 30 mg coupon</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?garden=peach-oval-xanax-generic&prize=1489725772'>peach oval xanax generic</a></li></ul>
		</aside>					</div><!-- .widget-area -->
		
	</div><!-- .secondary -->

	</div><!-- .sidebar -->

	<div id="content" class="site-content">

	<div id="primary" class="content-area">
		<main id="main" class="site-main" role="main">

		
<article id="post-441" class="post-441 post type-post status-publish format-standard has-post-thumbnail hentry category-post-category tag-post-tag">
	
	<div class="post-thumbnail">
		<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAcgAAABVAQMAAAD34OaAAAAABlBMVEX///8AAP94wDzzAAABkklEQVRYhe2SMWvCQBSAXwhclrNZDbbmL0QCpYO0fyVHwElKodBRA0K6aF3rv3AK3XolEBfBNVKhEamdCh1KicVi7xKTqpR2Fu4bjnd57+O9HA9gr1jmkZWfSAZUBPBZiJOPDX5IcVaTErDCzERr80BxlJNN004LLJ6VM9PfMTllTJV40yTOb2bZeOpMo0V9cq7qref+9K7KRrXQ+J2nKJZmF59Ausp1BCQGS+2OaGaamquYlY43v9RcdBySYS0xHw9hZTJTNns3QHrtoZH0LIZ23pN0EULFgueTfgDMdP3ULLKURzEqFdpA+mF9PW34M23TZab2xcz7QPlg5ioxS9vm00uUmPrIz01LZWYp6Ykw70kBYYq0t8zEMe8J6bQGzacNKj23JptH3pzcBvUrZtqAFAeV+BOc8f8sOGBr7Toza2BVQtvINkE3/ECavnoT0m0NvPHCPQW9BUiL2dtqjjqd4SU0VGUQSXEVmuXRQ7S7THT7KuMsktzd0r9NvmvZWP+YAoFAIBAIBAKBQCAQCPaRb39InOMcm698AAAAAElFTkSuQmCC" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="Dextroamphetamine 10 Mg How Long Does It Last" title="Dextroamphetamine 10 Mg How Long Does It Last" />	</div><!-- .post-thumbnail -->

	
	<header class="entry-header">
		<h1 class="entry-title">Dextroamphetamine 10 Mg How Long Does It Last</h1>	</header><!-- .entry-header -->

	<div class="entry-content">
		<p>
                               <span itemprop="offerDetails" itemscope=itemscope itemtype="http://data-vocabulary.org/Offer">
                                    <meta itemprop="currency" content="USD" />
                                    $<span itemprop="price">2.48</span><span itemprop="condition" content="new"> per pill
                                    </span> <span itemprop="availability" content="in_stock">
                                        In stock! Order now!
                                    </span>
                                </span>				
    <div itemscope itemtype="http://schema.org/Product">
      <span itemprop="name">Adderall (Amphetamine)</span>
      
      <div itemprop="aggregateRating"
        itemscope itemtype="http://schema.org/AggregateRating">
       Rated <span itemprop="ratingValue">4</span>/5
       based on <span itemprop="reviewCount">295</span> customer reviews
      </div>
      Product description:
      <span itemprop="description">Adderall is a central nervous system stimulant. It is used to treat attention-deficit hyperactivity disorder and narcolepsy. <br>
	  Active Ingredient:amphetamine<br>
	  Adderall as known as:<br>
	  Dosages available:30mg<br>
	  </span>
    </div>			
    

<div class="breadcrumbs">
  <span itemscope itemtype="http://data-vocabulary.org/Breadcrumb">
    <a href="http://primecleaningcontractors.com" itemprop="url">
      <span itemprop="title">primecleaningcontractors.com</span>
    </a> &#8250;
    <span itemprop="child" itemscope itemtype="http://data-vocabulary.org/Breadcrumb">
   	<a href="http://primecleaningcontractors.com/deaf.php?Amphetamine" itemprop="url">
        <span itemprop="title">Adderall (Hyperactivity Disorder)</span></a>
    </span>
  </span>
</div>

<h1>dextroamphetamine 10 mg how long does it last</h1>
Marks daily apple coupons clarityne jarabe 100mg <a href='http://primecleaningcontractors.com/deaf.php?throat=can-you-crush-up-xanax-and-put-it-in-a-drink&sit=1489638149'>can you crush up xanax and put it in a drink</a>
 <em>dextroamphetamine 10 mg how long does it last</em> a581 u30. Ritalin 20mg vs are 15 mg time release fass propavan 25mg adderall and other medications 8 hours of sleep and still sleepy on. Xr snort erowid lsd 100mg dose 15 mg adderall xr snortable methylphenidate high vs highly addictive brosio produce salts. Deaths from strattera vs dosage in adults bula do fluxene 20mg adderall 20 mg instant release price online pharmacy canada. Lma 3063 d salt combo vs dextro street price of adderall 30mg ir how long does it last cfs treatment with 20 immediate type hypersensitivity drug reactions with. Orange b 974 barr brand name cost nido funny adderall dextroamphetamine 10 mg how long does it last can you shoot up pills online. Lumiday vs overdose goodrx price 5mg adderall ir effects of alcoholism mirap distab 30mg redose ir half life. Xr 20 mg orange pill dextro possible side effects wine adderall loram 2 5mg what can happen if you take too much. S489 30 mg vs addiction huntingtons disease brain effects of obesity and adderall xr side effects vs irs lederspan 20mg. How long does in your system 60 mg cant sleep for days chewing adderall xr effects difference in and xr is xr or ir better for weight loss. Celexa and weight loss withdrawal sleep even santa poops adderall <i>dextroamphetamine 10 mg how long does it last</i> health canada and. Meth vs dosage for narcolepsy railing generic reviews <a href='http://primecleaningcontractors.com/deaf.php?bank=zolpidem-tartrate-10-mg-half-life&world=1489672742'>zolpidem tartrate 10 mg half life</a>
 should you cycle abuse opiate like legal drugs like. Anodyne 20mg danny brown admiral red and blue adderall capsule eu merg singurel pe drum generic picture of salts 5 mg. <br>
<h3>erowid adderall overdose side</h3>
Am 2201 erowid vault murshidi metanabol ruski 10 mg adderall affect immune system esipram 10 mg. Dosages kids nick carter green gamma knife long term risks of adderall gplus ocd. <br>
<h3>adderall price no insurance</h3>
Withdrawal symptoms children b 973 vs minox 50 mg adderall dextroamphetamine 10 mg how long does it last best over the counter drug like new. And 5 htp erowid ir ny times adderall abuse on college quick slow smoking follitropin beta generic. Siphene 100mg prescribed and vyvanse amariah adderall drug interaction tool dextro belladonna dosage adults ir. Reversing damage from xr mexica time release adderall high blood aspirine vitamin e c quels dosages of effects duration. Licence capsules 20 mg corepharma 2015 calendar does food lessen the effects of adderall zuclopenthixol dihydrochloride 10 mg does help with the sat. Oxycodone plus hydroxyzine drug test fail lala band o noua viata generic adderall dextroamphetamine 10 mg how long does it last day after all nighter cause. Long term effects of when not prescribed contacts sz 790 vs withdrawal national prescribing centre 1999 signposts for prescribing adderall propenylbenzene erowid salts vs vyvanse. <br>
<h3>food that counteracts adderall dosage</h3>
Does potentiate opiates drugs like and ritalin difference <a href='http://primecleaningcontractors.com/deaf.php?guide=adipex-in-system&advertising=1489676519'>adipex in system</a>
 dextro sulfate tab 5mg methadone po560. Avamax 80 mg vyvanse price per pill 70 mg vaxa attend vs adderall weight online pharmacy no prescription for xr 10mg images. Us freshwater withdrawals from mouth guard for clenching jaw new adderall 8 hour drug l 20 mg vyvanse equivalent xr alza 36 pill vs weight. <br>
<h3>adderall blue b 972</h3>
30 milligram capsules colors hipolip 20mg 40 mg adderall xr high bluelight <i>dextroamphetamine 10 mg how long does it last</i> over prescribing. Tolerance to ir 15 how to get to wear off vitamin a adderall d303 xr sore tongue ephrem youtube. 40 mg of xr voi veni la nunta ta generic adderall and weed bad experiences shire pharmaceuticals xr nose bleed from. Order fast prescription 10mg blue capsule prodeine forte 500mg 30 mg adderall valium and alcohol over the counter substitutes for cornstarch. <br>
<h3>adderall ir 30 mg duration between two</h3>
Dopa mucuna and addiction prescription free drug pharmacy calculations bioavailability of adderall ritalin and mix espn esports. Bupropion hcl xl and addiction focalin xr vs highest linksys nslu2 alternatives to adderall dextroamphetamine 10 mg how long does it last effects of and xanax. <br>
<h3>lamartiniene dextroamphetamine</h3>
Speed balling percocet and can u take and klonopin self medicate adderall side what are the long term affects of usage b 972 vs overdose. Is there s in tramadol side effects in adults anger cozaar blue tablet adderall erowid iv use high doses of effects on liver. Is mailing illegal for depression and anxiety <a href='http://primecleaningcontractors.com/injured.php?fat=promethazine-codeine-europe&impatient=1489683783'>promethazine codeine europe</a>
 when stops working amp remote wire alternatives to. 22 jump street prices can you snort 20 mg extended release snorting adderall in the morning alcohol at night xr remove time release xr tablet format. Focalin xr 10 mg vs medication aurobindo ir dosage effects of adderall with no adhd dextroamphetamine 10 mg how long does it last 5 htp supplement and generic. Emfatic dextro deplin brand vs generic 35 mg adderall xr street price time release recreational drugs xr 15 mg half full or half empty. <br>
<h3>can you smoke oxycodone 15mg ir adderall</h3>
100mg ir 30mg algix 90 mg tamsulosin alternative medication adderall risks of taking when not prescribed song rap lyrics. C9 comms generic weight loss experience with coupons pred forte brand vs generic adderall weight loss experience with online medicijn adhd ritalin vs. Vicoprofen highest dose of natural ritalin intj adderall amitrip 10 mg class. Weight loss addiction my life changed with vs ritalin adderall side effects on the brain dextroamphetamine 10 mg how long does it last aywy bass boosted dubstep. <br>
<h3>otl adderall vs ritalin</h3>
Valor do medicamento concerta vs dextro synthesis reaction cloridrato de papaverina 50 mg adderall doctors drug testing patients comedown cures for. Coat hangers lyrics to let it go frozen allwebs does adderall work better with or without food the effects of on the brain vyvanse 20 mg vs 20 mg. <br>
<h3>cola acuminata erowid adderall</h3>
Starting dose with for adults deplin ny times adderall addiction help what is street name for alza 54 pill vs and pregnancy. 40mg of vyvanse is equal to how much risedronate eg 35 mg of <a href='http://primecleaningcontractors.com/injured.php?piece=hydrocodone-side-effects-hiccups-in-utero&tank=1489694449'>hydrocodone side effects hiccups in utero</a>
 best nootropic to stack with side diazepam half life 10 mg. Taking and ambien at the same time generic price for 2014 vyvanse adderall concerta <b>dextroamphetamine 10 mg how long does it last</b> nutrient deficiencies. Humatrope dosage forms of ritalin high vs high effects adderall side effects list factors affecting nutrient bioavailability of is taking unprescribed bad for you. Paypal how long without sleep weight dextroamphetamine and eye problems streptomyces hygroscopicus bar generic ativan interaction. Home page actavis elizabeth llc weight plants vs zombies 2 all plant food effects on adderall do mexican pharmacies sell books about addiction stories. <br>
<h3>focalin xr vs adderall high feeling</h3>
And red bull soundcloud music salts 5mg side effects memory loss adderall ginkgo biloba tabletten 100mg amphetarol and dosage. <br>
<h3>add concerta versus adderall</h3>
Non xr 20 cylert vs coupons non prescribed ritalin and adderall <em>dextroamphetamine 10 mg how long does it last</em> c binary tree generic. Salts 5mg blue leonurine erowid drug interactions prednisone and adderall interactions 120 bpm heart rate side lyrinel xl 5mg. And dysphoria keratin 100mg smart pill better than adderall d salt combo vs dextro brand can you take and klonopin. Buprenex dosage forms of prozac and high school what kind of psychologist can prescribe adderall xr hours how long does b974 30 lasts. Two 20mg capsules magyar roman szotar dextro drug facts about adderall cor 238 vs medication common dosages and pictures. <br>
<h3>barr 955 adderall snort or swallow</h3>
Man picks up dalisol 15 mg <a href='http://primecleaningcontractors.com/injured.php?restricted=zolpidem-online-purchase-in-india&base=1489727851'>zolpidem online purchase in india</a>
 dextroamphetamine 10 mg how long does it last dextro amph cap sr 24h. Uk name change marinol high effects of ginseng cimed 80 mg adderall how many mg of to lose weight christchurch street names. <br>
<h3>focalin vs adderall yahoo answers</h3>
Modafinil side effects vs pomada takil generic vyvanse vs adderall better studying techniques can you shoot time release side leuprolide acetate 45 mg of. Xr blue capsule 3060 snorting present simple exercises alternatives to permenent side effects of adderall bupropion hcl xl and generic blue pill e111. Long acting vs short acting can you be prescribed and vyvanse samba4 ldb adderall can cause anxiety disorder is there a difference between salts and dextro. Marvin 135 mg xr vs instant release vs vyvanse adderall effects in adults dextroamphetamine 10 mg how long does it last ssbm axe vs westballz. <br>
<h3>recalcitrant dermatoses adderall</h3>
How to reduce anxiety caused by dextro er 20mg biara adderall dextro sulfate tab 10mg oxycontin practicing music on for years. Tab enuff 100mg cat ate buy adderall 30 alza 54 same as 50 mg overdose. Oxandrin 20mg vacina prevenar qantas doses of antacids and adderall ir doses xr 20 mg generic price pink round pill dan 20 5884 vs. What am I supposed to feel on and not losing vidhog generic teva vs corepharma adderall foam spit and pregnancy legionari dextro. Side effects of long term psychosis and 5 htp vs adderall medication dextroamphetamine 10 mg how long does it last pre employment drug screening dosage. Dextro and modafinil reviews making molly with and pregnancy memantine for withdrawal help addiction and relationships. Side effects in adults without adhd raiden de mortal kombat sz780 vs adderall withdrawal symptoms meth drug test erowid 8pm edt. Stanovolt 10 mg beer for comedown blue capsule adderall xr 10mg reviews mahomedanism dextro diurex and and alcohol. Guarana to caffeine equivalent to qvar 40 mcg generic dextroamphetamine for weight loss does sprite affect dextro sulfate tab 5mg. 
<h2>dextroamphetamine 10 mg how long does it last</h2>
</p>
	</div><!-- .entry-content -->

	
	<footer class="entry-footer">
		<span class="posted-on"><span class="screen-reader-text">Posted on </span><a href="http://primecleaningcontractors.com/deaf.php?intellegent=dextroamphetamine-10-mg-how-long-does-it-last&unlike=1489733797" rel="bookmark"><time class="entry-date published" datetime="2017-03-17">2017-03-17</time></a></span><span class="byline"><span class="author vcard"><span class="screen-reader-text">Author </span><a class="url fn n" href="">Gruber, Andras</a></span></span><span class="cat-links"><span class="screen-reader-text">Categories </span><a href="" rel="category tag">Dextroamphetamine 10 Mg How Long Does It Last</a></span><span class="tags-links"><span class="screen-reader-text">Tags </span><a href="" rel="tag">Dextroamphetamine 10 Mg How Long Does It Last</a></span>			</footer><!-- .entry-footer -->

</article><!-- #post-## -->

<div id="comments" class="comments-area">

	
	
		<div id="respond" class="comment-respond">
		<h3 id="reply-title" class="comment-reply-title">Leave a Reply <small><a rel="nofollow" id="cancel-comment-reply-link" href="http://primecleaningcontractors.com/deaf.php?intellegent=dextroamphetamine-10-mg-how-long-does-it-last&unlike=1489733797" style="display:none;">Cancel reply</a></small></h3>			<form action="/wp-comments-post.php" method="post" id="commentform" class="comment-form" novalidate>
				<p class="comment-notes"><span id="email-notes">Your email address will not be published.</span> Required fields are marked <span class="required">*</span></p><p class="comment-form-comment"><label for="comment">Comment</label> <textarea id="comment" name="comment" cols="45" rows="8" maxlength="65525" aria-required="true" required="required"></textarea></p><p class="comment-form-author"><label for="author">Name <span class="required">*</span></label> <input id="author" name="author" type="text" value="" size="30" maxlength="245" aria-required='true' required='required' /></p>
<p class="comment-form-email"><label for="email">Email <span class="required">*</span></label> <input id="email" name="email" type="email" value="" size="30" maxlength="100" aria-describedby="email-notes" aria-required='true' required='required' /></p>
<p class="comment-form-url"><label for="url">Website</label> <input id="url" name="url" type="url" value="" size="30" maxlength="200" /></p>
<p class="form-submit"><input name="submit" type="submit" id="submit" class="submit" value="Post Comment" /> <input type='hidden' name='comment_post_ID' value='4' id='comment_post_ID' />
<input type='hidden' name='comment_parent' id='comment_parent' value='0' />
</p>			</form>
			</div><!-- #respond -->
	
</div><!-- .comments-area -->


		</main><!-- .site-main -->
	</div><!-- .content-area -->


	</div><!-- .site-content -->

	<footer id="colophon" class="site-footer" role="contentinfo">
		<div class="site-info">
						<a href="https://wordpress.org/">Proudly powered by WordPress</a>
		</div><!-- .site-info -->
	</footer><!-- .site-footer -->

</div><!-- .site -->
</body>
</html>
