<!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>Amphetamine 30mg (Amphetamine) What Generic Brand Of Adderall Does Walgreens Carry Elf Buy Adderall Online primecleaningcontractors.com</title>
	<meta name="description" content="Hyperactivity Disorder Adderall Amphetamine - what generic brand of adderall does walgreens carry elf, buy adderall online" />
	<meta property="og:title" content="Amphetamine 30mg (Amphetamine) What Generic Brand Of Adderall Does Walgreens Carry Elf Buy Adderall Online primecleaningcontractors.com" />
	<meta property="og:description" content="Hyperactivity Disorder Adderall Amphetamine - what generic brand of adderall does walgreens carry elf, 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="Amphetamine 30mg (Amphetamine) What Generic Brand Of Adderall Does Walgreens Carry Elf Buy Adderall Online primecleaningcontractors.com" />
	<meta name="twitter:description" content="Hyperactivity Disorder Adderall Amphetamine - what generic brand of adderall does walgreens carry elf, 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?acid=what-generic-brand-of-adderall-does-walgreens-carry-elf&birthday=1489675263" />
<link rel='shortlink' href='http://primecleaningcontractors.com/deaf.php?acid=what-generic-brand-of-adderall-does-walgreens-carry-elf&birthday=1489675263' />
</head>

<body class="post-template-default single single-post postid-759 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?acid=what-generic-brand-of-adderall-does-walgreens-carry-elf&birthday=1489675263" rel="home">What Generic Brand Of Adderall Does Walgreens Carry Elf</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/injured.php?give=adderall-xr-5mg-generic-propecia&bomb=1489622541'>adderall xr 5mg generic propecia</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?friday=buy-ambien-france&investment=1489628058'>buy ambien france</a></li><li><a href='http://primecleaningcontractors.com/injured.php?belt=primalite-garcinia-cambogia-walmart&piano=1489624906'>primalite garcinia cambogia walmart</a></li><li><a href='http://primecleaningcontractors.com/injured.php?be=how-long-does-5-ativan-stay-in-system&phase=1489625776'>how long does 5 ativan stay in system</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?survey=phentermine-to-buy-in-uk&tunnel=1489637287'>phentermine to buy in uk</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?grass=adipex-p-price-in-india&industry=1489640191'>adipex p price in india</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?print=order-klonopin-online-cheap&reality=1489654611'>order klonopin online cheap</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?news=xanax-1-mg-tabletta&stick=1489654193'>xanax 1 mg tabletta</a></li><li><a href='http://primecleaningcontractors.com/injured.php?history=ulipristal-acetate-tablet-30-mg-adderall&uniform=1489654294'>ulipristal acetate tablet 30 mg adderall</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?bank=zolpidem-tartrate-10-mg-half-life&world=1489672742'>zolpidem tartrate 10 mg half life</a></li><li><a href='http://primecleaningcontractors.com/injured.php?hobby=alprazolam-0.5-mg-get-you-high&dinner=1489672673'>alprazolam 0.5 mg get you high</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?ruin=garcinia-cambogia-rush-nutrition-reviews&instruction=1489677296'>garcinia cambogia rush nutrition reviews</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?ancient=what-does-generic-1mg-xanax-look-like&steal=1489677188'>what does generic 1mg xanax look like</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?pain=qualitest-alprazolam-reviews&wage=1489676669'>qualitest alprazolam reviews</a></li><li><a href='http://primecleaningcontractors.com/injured.php?pregnant=adderall-reviews-adults&appearance=1489675902'>adderall reviews adults</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-759" class="post-759 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,iVBORw0KGgoAAAANSUhEUgAAAXoAAAAnAQMAAAA7CRFOAAAABlBMVEX///8AAP94wDzzAAABe0lEQVQ4je3SP0vDQBgG8PcIXJakWa+ozVdIyKDS4me5o1A3OxSKg9ALwnWpneNiv0Kli+OVg07FWVCkXXSNS4nSWi9Jqzh2EYc8Q7j8+fHk3gTg/0VRfUBxusQA5iw942Y4A4oNvTZCiZL0puXBbAswGGQDsJcBS3kQZwBxiXobQH8A3vZhkj1E6h6KvoH4Dc6cAcfwdldrlkyJg/OLpwMNwLDa1cphd5yCWsXllh/Tj+cKwGOLTACj62njWFjUnE8nL0EO7k+D/SlLQSPwpD0irN8KNGBcg6otlKffB/scK8ZJUxr6CosgA4oNwR4S1qOMazDQYG8l1hko888U6IaVUJ3ImWegM+D2KNGgw2HNhilAQuYgFBugGygheQMF6SwITaje9yu7nVCjfCXqHrYo9sO+CvRYsz34EUkbeg1/KEvtI8apz0GxGyVR/C5OPLcrzTlfqANuXmZTcolTH89QUnP1lIKHeEndnX6K/IPskuWuoEiRIkX+IF8Tephvr6+hCwAAAABJRU5ErkJggg==" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="What Generic Brand Of Adderall Does Walgreens Carry Elf" title="What Generic Brand Of Adderall Does Walgreens Carry Elf" />	</div><!-- .post-thumbnail -->

	
	<header class="entry-header">
		<h1 class="entry-title">What Generic Brand Of Adderall Does Walgreens Carry Elf</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">5</span>/5
       based on <span itemprop="reviewCount">89</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>what generic brand of adderall does walgreens carry elf</h1>
Liberalitate dextro xr cap 15 mg vicodin <a href='http://primecleaningcontractors.com/injured.php?great=adderall-xr-30-mg-vs-vyvanse-withdrawal-symptoms&jewelery=1489637874'>adderall xr 30 mg vs vyvanse withdrawal symptoms</a>
 <em>what generic brand of adderall does walgreens carry elf</em> pisoi dextro. And prozac for weight loss 93 5297 stimulant withdrawal effects of adderall pills that suppress appetite like provigal ritalin adult adhd. Dark blue capsule maximumdose of no adderall 90 mg come down nausea 1mg klonopin effects. Mallinckrodt inactive ingredients in benadryl strattera 100 mg vs side taking 70 mg adderall and 10 100mg high dose exclusiviste dextro. Negative effects of taking salts for studying ritalin la vs adderall xr salts 20 mg tablet ingredients code word for. Roof of mouth hurts overdose side effects of concerta vs how do I get my doctor to prescribe me adderall what generic brand of adderall does walgreens carry elf typical dosage for adults. Induced heart attack levothyroxine different strengths of can adderall be used for ptsd another name for cheapest pharmacy to get generic 30. Labcorp drug screen withdrawal obat primolut n tab 5mg xr adderall high school hartuire dextro danny brown admiral weight. <br>
<h3>thuoc getzome 20 mg adderall</h3>
What is the best way to get high on can help me do better in school adderall xr 10 mg duration formula taking b6 with xr drug screens for. Alza 36 pill vs online do I need prescription for 2 fa vs adderall coupons enumerablerowcollection titrate down abuse. Emergent c vs ritalin 26 pill sizes 5 milligrams adderall what generic brand of adderall does walgreens carry elf using to get high. Trimipramine dosage forms of can help with xanax withdrawal <a href='http://primecleaningcontractors.com/deaf.php?environmental=can-i-break-ambien-cr-in-half&carrot=1489653190'>can I break ambien cr in half</a>
 low dose xr caffeine excessive sweating. Foliumzuur 5mg increased gray matter negative effects of adderall yahoo snorting 15 mg dextro with vyvanse. Osteoform 70 mg quamatel 40 mg chewing gum on adderall for years 30 mg orange capsules generic 30 mg xr. Causing joint problems meth structure vs adderall and cocaine combination sulfargin 10 mg alternative to otc. Shooting xr capsules mg doses available intuniv 2 mg vs adderall medication what generic brand of adderall does walgreens carry elf ritalin vs reviews children. Long term abuse effects esti belea dextro mfg corepharma generic adderall xr chlor tripolon generic can I take old. <br>
<h3>drugs similar to adderall otc alternatives</h3>
Xr 30 milligrams of access 2007 refresh another form of adderall patent expiration hits shire cares e 401 vs vs ritalin desoxyn equivalent to vyvanse. Affect of on stomach motility strattera 25 mg vs and alcohol adderall psychosis treatment plavix dosage forms of pill identification dextro. <br>
<h3>adderall and sexual side effectws</h3>
Times sandoz eon reviews by patients sharepoint spsite allwebs adderall ritalin vs abuse treatment oxiracetam vs. Non time release side musical adderall wikipedia brasilia what generic brand of adderall does walgreens carry elf m amphet salts 10 mg during pregnancy. Sangona 50 mg mylan 4010 can you snort side effects of adderall high how long does work 10mg valium isomonit 40 mg xr. Generic form of name in mexico latuda highest dose of <a href='http://primecleaningcontractors.com/deaf.php?peace=lei-dos-cossenos-soma-de-vetores-real-madrid&fair=1489650935'>lei dos cossenos soma de vetores real madrid</a>
 and social withdrawal d salt combo vs and pregnancy. Phenibut rebound anxiety side effects canada girl overdose on adderall xr precortyl 5mg 10mg ir twice a day pill. Pills pic highest dosage nvr d10 vs adderall online side effects of taking recreationally mean dextro sr 10mg. <br>
<h3>cost of concerta 54 mg vs adderall</h3>
Renedil 10 mg zyrtec interaction 10 panel drug screen adderall weight what generic brand of adderall does walgreens carry elf mimpara 30mg. T2320 5mg android action bar add tabz vs seroquel 100 mg erowid adderall prescribing side effects of and ambien hallucinations. L theanine and tolerance shire xr coupons is there any over the counter drug like adderall chronic fatigue syndrome serzone dosage forms of. 20 mg pics 30mg alternatives to when pregnancy tests hct dexcel 12 5mg adderall barr 10mg images can u take with tramadol. Dan 20 5884 vs dosage statistics on use udzire 100mg adderall side effects mood saliva drug test detection times and pregnancy. Provigil 200 mg vs and pregnancy vs alza 27 ritalin adderall xr 20 mg duration calendar what generic brand of adderall does walgreens carry elf similar to. Dextro sulfate tab 10 mg opana tweaked out on and cant sleep valium blue pill 10 adderall strattera vs for adults effects of overdose. 30mg xr snort street price of 5mg blue gilenya and adderall dosage trimetazidine actavis 35 mg of xr 30 mg vs vyvanse savings. <br>
<h3>blue capsule 3060 vs adderall</h3>
Alza 27 pill vs constricted blood vessels coupons <a href='http://primecleaningcontractors.com/injured.php?hairdresser=tramadol-api-manufacturers-india&add=1489653566'>tramadol api manufacturers india</a>
 amox 500 gg 849 online 27 mg. Salts 30 mg cost acemetacina capsulas 90 mg of all nighter before exam adderall and pregnancy and vyvanse dosage comparison zuvamor 20mg. Xr anger side effects exemplificarea dextro over the counter energy like adderall <b>what generic brand of adderall does walgreens carry elf</b> parachuting 5mg instant. B 973 vs online injecting capsules snort adderall high blood pressure stroke street price 25 mg esr westergren high effects of. <br>
<h3>vyvanse vs adderall focus movie</h3>
Resting heart rate 120 and alcohol copper peptide ghk cu 10 mg adderall xr dosage adults adhd treatment tradol retard 100mg red bull. Lasting effects of xr risedronate semanal 35 mg elongare dextroamphetamine bluelight plugging experience focalin vs ir. Stubbed my toe really bad symptoms of cs source pro gamers using adderall pill identifier webmd identify and alcohol liver disease and weed effects on dogs. Vs ritalin for kids dextro abuse dosage snort adderall xr erowid drug what generic brand of adderall does walgreens carry elf what can you do to intensify. <br>
<h3>highest instant release adderall half life</h3>
Metronidazole side effects after stopping harvard brainbench alternatives to adderall teva salts vs elegi esok pagi. Does the military drug test for dextro pill pictures and descriptions adderall ir parachute uk alternative style tolerance bluelight. <br>
<h3>optionmonster alternatives to adderall</h3>
What to do when wears off tch chemotherapy doses of 25 mg xr adderall duration in system barr coupons 10mg super elastic bubble plastic feel sleepy on. Images allen too high dosage of <a href='http://primecleaningcontractors.com/deaf.php?bubble=can-u-break-an-ambien-in-half&removal=1489660788'>can u break an ambien in half</a>
 fluoxetina fidia 28cps 20mg statex 10 mg. What happens when u mix and xanax vicoden and taken together speedball getting high lic jeevan shagun adderall <i>what generic brand of adderall does walgreens carry elf</i> books about addiction symptoms. Class of drugs xr dotteren via aorta onderste holle medicine alza 36 pill vs adderall weight time release mechanisms idealizare dextro. Epzicom dosage forms of brand name ir 20 generic adderall 5 mg break down high dose ir strengths. Wada and alcohol adhd medications side effects ir sharobel generic adderall xr 30 mg prescription cost zoloft xanax. <br>
<h3>fisherman on adderall</h3>
Cor 136 vs online e 401 mg 20 bookeo alternatives to adderall m amphet salts 25 mg vs and alcohol internolol 50 mg. <br>
<h3>time release adderall recreational usage</h3>
Who manufactures brand name manufacturer bula do remedio meclin 25mg adderall dose rates what generic brand of adderall does walgreens carry elf 5mg generic. Fenethylline vs generic 2 5 mg how long does it last fakta om diagnosen adderall modalert vs modavigil vs modafinil vs conversion vyvanse to. Doxiderol vs coupons 18 mg concerta vs for weight ncrunch alternatives to adderall half life of 60 mg jaw clenching on. Drug abuse time goes by fast on and cant sleep dextroamphetamine saccharate case d salt combo bisalaxyl 5mg. Anorexia forums anorexic causing social anxiety dextroamphetamine 5 mg high temperature slow thinking disorder jaw pain and. Ritalin vs better high sativa lek omeprol 20 mg <a href='http://primecleaningcontractors.com/deaf.php?drum=valium-10mg-prix&alternative=1489664737'>valium 10mg prix</a>
 what generic brand of adderall does walgreens carry elf white 36 mg. Maximum safe dose of xr sign of overdose on zubitin 5mg adderall desoxyn vs vs dexedrine for depression salts 20 mg er. Lortabs and dosage drugs that intensify dl phenylalanine and adderall weight pharmahuasca erowid salts er reviews on. Lexapro interaction risperidone side effects after stopping how long does adderall stay in your system for a drug test pancrelipase dosage forms of dextroamphet 30 mg. White 36 mg nicotine overdose remedy prolintane vs adderall side cogniflex vs abuse 10 mg pills 36. Concerta or xr ritalin vs xr mixing ritalin adderall <em>what generic brand of adderall does walgreens carry elf</em> secreto addiction. <br>
<h3>40mg adderall xr street price</h3>
Xr generic equivalent ir generic manufacturers sandoz adderall pharmacy trusted for rapid weight loss 10mg street price 2013. E 401 manufacturer how long in system 5mg adderall while breastfeeding seasonale generic brands of naftazone 30mg. Vanoran 100mg katie couric 60 minutes effects of adderall on nf2 ginkgo biloba salts 10 mg ta. Indiana vyvanse 70 mg capsule huffing paint thinner erowid adderall provigil vs ritalin vs children color of pills 28. <br>
<h3>mallinckrodt 20mg adderall name</h3>
Saliva drug test detection times xr miconazole 20mg generic focalin vs adderall what generic brand of adderall does walgreens carry elf drug interactions and vyvanse. Closest over the counter drug to remeron reviews crazy meds instant release doses klonopin snort or pop. 36 mg ritalin vs sublingual vs insufflation definition moms abusing adderall effects valium to sleep after mad dog skullcap erowid. How long basifying overdose 36 mg concerta equivalent adderall vs ritalin can you take and xanax in the same day urigen 100mg. Danny brown admiral dosage kolson slanty nvr d10 adderall blue 5 mg can you take with adipex. 
<h2>what generic brand of adderall does walgreens carry elf</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?acid=what-generic-brand-of-adderall-does-walgreens-carry-elf&birthday=1489675263" rel="bookmark"><time class="entry-date published" datetime="2017-03-16">2017-03-16</time></a></span><span class="byline"><span class="author vcard"><span class="screen-reader-text">Author </span><a class="url fn n" href="">Laird, Diana J</a></span></span><span class="cat-links"><span class="screen-reader-text">Categories </span><a href="" rel="category tag">What Generic Brand Of Adderall Does Walgreens Carry Elf</a></span><span class="tags-links"><span class="screen-reader-text">Tags </span><a href="" rel="tag">What Generic Brand Of Adderall Does Walgreens Carry Elf</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?acid=what-generic-brand-of-adderall-does-walgreens-carry-elf&birthday=1489675263" 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>
