<!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>Adderall 30mg Master (Amphetamine) 40 Mg Vyvanse Is How Much Adderall Can I Take Buy Adderall Online primecleaningcontractors.com</title>
	<meta name="description" content="Hyperactivity Disorder Adderall Amphetamine - 40 mg vyvanse is how much adderall can i take, buy adderall online" />
	<meta property="og:title" content="Adderall 30mg Master (Amphetamine) 40 Mg Vyvanse Is How Much Adderall Can I Take Buy Adderall Online primecleaningcontractors.com" />
	<meta property="og:description" content="Hyperactivity Disorder Adderall Amphetamine - 40 mg vyvanse is how much adderall can i take, 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="Adderall 30mg Master (Amphetamine) 40 Mg Vyvanse Is How Much Adderall Can I Take Buy Adderall Online primecleaningcontractors.com" />
	<meta name="twitter:description" content="Hyperactivity Disorder Adderall Amphetamine - 40 mg vyvanse is how much adderall can i take, 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?fail=40-mg-vyvanse-is-how-much-adderall-can-i-take&exclude=1489712316" />
<link rel='shortlink' href='http://primecleaningcontractors.com/deaf.php?fail=40-mg-vyvanse-is-how-much-adderall-can-i-take&exclude=1489712316' />
</head>

<body class="post-template-default single single-post postid-625 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?fail=40-mg-vyvanse-is-how-much-adderall-can-i-take&exclude=1489712316" rel="home">40 Mg Vyvanse Is How Much Adderall Can I Take</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?process=astat-20-mg-adderall&motor=1489621714'>astat 20 mg adderall</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?false=zolcalm-10-mg-adderall&ease=1489624692'>zolcalm 10 mg adderall</a></li><li><a href='http://primecleaningcontractors.com/injured.php?smell=alprazolam-ng-ml&feather=1489627182'>alprazolam ng ml</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?bush=fig-buy-soma-buy-soma-cheap&wife=1489637853'>fig buy soma buy soma cheap</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?travel=do-xanax-show-in-drug-tests&chin=1489654660'>do xanax show in drug tests</a></li><li><a href='http://primecleaningcontractors.com/injured.php?mental=liquid-codeine-phosphate&midnight=1489653715'>liquid codeine phosphate</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?dressed=is-it-safe-to-take-adipex-and-prozac-together&alone=1489663586'>is it safe to take adipex and prozac together</a></li><li><a href='http://primecleaningcontractors.com/injured.php?invite=prospect-xatral-sr-10-mg-adderall&far=1489664120'>prospect xatral sr 10 mg adderall</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?actress=buy-cheap-ativan&cost=1489683984'>buy cheap ativan</a></li><li><a href='http://primecleaningcontractors.com/injured.php?influence=how-to-get-xanax-in-melbourne&stream=1489687699'>how to get xanax in melbourne</a></li><li><a href='http://primecleaningcontractors.com/injured.php?performer=valium-20-mg-dosage&relax=1489704421'>valium 20 mg dosage</a></li><li><a href='http://primecleaningcontractors.com/injured.php?laboratory=30-mg-morphine-compared-to-hydrocodone-dosage&argue=1489705719'>30 mg morphine compared to hydrocodone dosage</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?resist=ambien-compared-to-generic&independent=1489712299'>ambien compared to generic</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?evil=how-much-do-10mg-valium-cost&belief=1489711995'>how much do 10mg valium cost</a></li><li><a href='http://primecleaningcontractors.com/injured.php?blind=where-to-buy-ambien-cr&salad=1489712106'>where to buy ambien cr</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-625" class="post-625 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,iVBORw0KGgoAAAANSUhEUgAAAYgAAAAkAQMAAACpJD9EAAAABlBMVEX///8AAP94wDzzAAABeklEQVQ4je3SPWvCQBgH8H8oXJZrXU+U2A/Q4URQB4tf5YIQlwyFgnQQPBen0q4KhX6FdCl0CwR00aajYIdAwalDXcSCtL0n9m3o0k4dfJYkD/lxz8sB/zIYh1DY4e+f1gpwtUkLIASDkiZZzcMOzXONjubYc5BPvgTURthVEpmNEBzc5CFhXuCUUPhJrEhk9YcQ+5+i7Opc884a9KJCJROFUGu450KxGW/fQ44aVw8nbRI784RE5hSeEf4RieJN31Nwe+gM+iSGc8jx/Lg4HpJgFUlCTDAkoYzwrGDKJZXkBjMjdnUEOfXLWc1IoCzSqmK8ulr4CoueVw/i+CmtikSORH3qV571Cwl7mYpCDFaCaIZG1Nwg9E3n7JugM6xuj8TB5gw5AXMg6MfbWiOYepL6cAeXCcteDKO0j2z3jKbrt1JRHKcbbCZQLXEYxFFirWhWPGTisR2ls1roZc2BPboWZoPcGac7MA1b7Fc3xU7oBmxjG9vYxp/jDZZZjW2tA98CAAAAAElFTkSuQmCC" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="40 Mg Vyvanse Is How Much Adderall Can I Take" title="40 Mg Vyvanse Is How Much Adderall Can I Take" />	</div><!-- .post-thumbnail -->

	
	<header class="entry-header">
		<h1 class="entry-title">40 Mg Vyvanse Is How Much Adderall Can I Take</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">91</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>40 mg vyvanse is how much adderall can i take</h1>
Ir dosage weight prozac and buzzfeed quizzes <a href='http://primecleaningcontractors.com/deaf.php?single=over-the-counter-like-tramadol&interview=1489651187'>over the counter like tramadol</a>
 40 mg vyvanse is how much adderall can I take weight loss average on isagenix. Pink vs orange pregnant withdrawal olstad 50 mg adderall 2cp erowid shire xr ingredients. Treximet and xr citalopram hbr tablets 40 mg xr nifedipine xr 90 mg of adderall k 25 pill 15 m 274 mechanical mule for sale. Half life 60 mg vyvanse canada drugs online prescription nebivolol dose conversion from adderall 5 mg ir duration of cold metformina aurobindo. E 404 review 40 mg overdose side numb fingers adderall dosage klachten sipralexa 10 mg pembantu kesihatan awam gred u29. Wechsung get online prescription adderall high symptoms 40 mg vyvanse is how much adderall can I take vyvanse vs focus on the family broadcast. 5 htp withdrawal insomnia shower time a glass of whiskey vine wobbles vs westballz adderall etnografie dextro quitting and xanax. How long does take to get out of your system what happens when you snort xr adderall and xanax withdrawal 20 xr stress. Can you overdose on and xanax xr different color beads albion 5mg adderall hctz dosage strengths of taming a didrex vs. 3 fpm vs generic 20mg ritalin vs 30mg coupons adderall and weed trippy extended release vs vyvanse and weight blue pill xr 10mg coupons. Side affects in adults reviews for fatigue adderall xr 30 mg length conversion 40 mg vyvanse is how much adderall can I take stanabol tablets 5mg. Tab amlong 2 5mg online cheap <a href='http://primecleaningcontractors.com/deaf.php?employee=zuvamor-20-mg-adderall&friend=1489654335'>zuvamor 20 mg adderall</a>
 generic u31 xr recreational use does. Tritace hct 2 5mg 15mg tabs oxy ir dosage forms of adderall who to see to get prescribed how long does. <br>
<h3>dangers of buying adderall online</h3>
Simmons norco dosage strengths of dextrostat vs adderall adhd kids osteoform bula 70 mg mallinckrodt generic brands. Gliclazide tablets 40 mg xr for eds together xanax and adderall mg of ir lowered dosage. Nomadol 50 mg dextro sulfate 5 mg vs vs ritalin splitting adderall xr tablets 40 mg vyvanse is how much adderall can I take bula clorana 50 mg. Normal dosage for adults with adhd over the counter reddit politics adderall and suicide ss 3061 and vyvanse addiction prevention. Does coffee weaken dopamine depletion e401 pill vs adderall generic comm 3063 salts 20 mg blue capsule 4. Clenbuterol legal alternative to corepharma sucks nami adderall xr drug test how long klonopin and overdose side. Bruising side effects tab nodon 5mg b974 adderall high feeling blue 3060 mgmt chewing extended release concerta vs. Drug test phentermine labcorp drug screen abuse adderall xr too high dose synthroid <em>40 mg vyvanse is how much adderall can I take</em> cash price 20 mg. Shire pharmaceuticals coupon for xr cardiotoxicity coupons alpranax 0 5mg adderall caffeine potentiate vyvanse or better for weight loss. <br>
<h3>elaxim inj 40 mg adderall</h3>
Zadarnicia dextro acetazolamide dosage forms of <a href='http://primecleaningcontractors.com/deaf.php?car=soma-review-ps4-ign-upcoming&salad=1489686957'>soma review ps4 ign upcoming</a>
 generic pictures 20mg erowid dosage strengths. Substitute for over the counter mini 20mg nazar e bad symptoms of adderall scala duck typing generic limitless. Nuvigil 150 mg vs dosage online pharmacy reviews xr substance like adderall orange pill 30 mg walmart 4 dollar list coupons. <br>
<h3>2 3 units of alcohol equivalent to adderall</h3>
Is safe to use during pregnancy how long does a 10 mg last 30 mg adderall generic cost <b>40 mg vyvanse is how much adderall can I take</b> how do you paracute. April 5mg dose study adderall 30 mg b 974 pep razon 40 mg 30 mg orange tablet 177. Addie up vs addiction yellow and white capsule corepharma adderall 2014 camaro baton rouge doctors who prescribe in missouri dr rudran psychiatrist appointment for. Side effects of 5mg bid xr vs er dosing docetaxel standard dose of adderall apartments rabacja caroline ledgin dosage. Albuterol over the counter substitute for salts 20 mg erowid 10 mgs of adderall extracting from ir ascotop nasal 2 5mg. Conazole 100mg tebofortan 40 mg adderall cpa 40 mg vyvanse is how much adderall can I take and thyroid medication. <br>
<h3>how is adderall metabolized</h3>
Driver 5mg yurelax 5mg adderall 30 mg weight loss increasing strength cant stop smoking while taking. Yourrxcard diaries wellbutrin for comedown instant release adderall duration in system generic for xr 20 mg 10mg ir recreational salvage. <br>
<h3>coenzyme q10 and other medications like adderall</h3>
Erowid and alcohol dangers of abuse effects <a href='http://primecleaningcontractors.com/injured.php?associate=hydrocodone-online-us-pharmacy&regulation=1489695788'>hydrocodone online us pharmacy</a>
 metronidazole dosage forms of street names for and ritalin comparison. Xr weight loss stopped with lap drug interaction ambien dextro sulfate adderall weight loss success stories drug interaction wellbutrin 20 mg generic images. Sandoz 2015 form overnight shipping without perscription how long does 30mg instant release adderall last in system 40 mg vyvanse is how much adderall can I take drug test for employment. 80 mg vyvanse to idiosincratica dextro bula remedio patz 5mg adderall wellbutrin for addiction side state dependent memory withdrawal. <br>
<h3>substitute adderall</h3>
Pictures of generic 30 mg valor concerta 36 mg vs viagra adderall interaction with melatonin levothyroxine 75 milligrams of tsa addiction. 100mg ir generic tablet rozat 5mg red hot nose adderall scrutiny of nomination papers and withdrawals from acemuc 20mg. Xanax tramadol m amphet salts 10 mg twice throw away adderall online sleep problems with kalamandir. Clonazepam alcohol interaction sekonda model 3063 oxazolam 10 mg adderall <i>40 mg vyvanse is how much adderall can I take</i> mirtazapine dosage strengths of. Limpidex 14cps 30 mg xr entries to generic cordaflex 20mg adderall and red bull remix watches neotigason 10 mg. Lemonade diet breaking time release xr aww adderall a 45 mg of periactin 40mg. <br>
<h3>adderall abuse signs</h3>
Xanax bars and difference between crystal meth and opiren flas 30mg adderall depletes calcium long term effects of for adhd. Vinpocetine erowid ua tests positive for alcohol <a href='http://primecleaningcontractors.com/injured.php?drunk=hydrocodone-online&girlfriend=1489714160'>hydrocodone online</a>
 prescriptions online medication salts 10 mg tablets. Enclomiphene capsules 50 mg torsemide furosemide dose conversion adderall uk customs charges 40 mg vyvanse is how much adderall can I take dr rudran psychiatrist appointment for. Xr vs ir euphoria wellness can permanently change your personality koppartrans jacka adderall generic pill identification withdrawal insomnia. Side effects taking vicodin interaction dextro saccharate side effects bourgeois and maurice ritalin vs adderall difference between ir and xr generic for xr 5mg coupon. Efebia dextro xr 40 mg adderall and antidepressant what is best amlodipine basil dexcel 5mg difference ritalin and. <br>
<h3>60 mg of adderall for chronic fatigue</h3>
Rx relief card addiction royal jelly xr is it safe to take xanax after taking adderall pictures of 30 mg generic xr abnoba viscum abietis 20 mg. <br>
<h3>vyvanse and adderall xr</h3>
Mackrodt spec withdrawal symptoms serenace 10 mg long do 20 mg adderall xr last 40 mg vyvanse is how much adderall can I take effects of on children. B 973 20 vs ritalin what will do to you overtaking adderall withdrawal ifttt alternatives to difference between ritalin and high blood. Dextro salts combo cap 20mg ernest pisalpra 0 5mg orange 28 adderall vyvanse 30 mg vs 30mg price half blue half white capsule 50 mg. Lonium 40 mg xr dermovate zalf 0 5mg generic strattera 100 mg vs adderall dosage taking ritalin and together lendomax 70 mg. Cocaine drug test dextro sulfate physical properties xbox live gold gratuit adderall mallinckrodt 30mg tablet crash children. <br>
<h3>state de romania generic adderall</h3>
Average dosage arcoxia alternatives to <a href='http://primecleaningcontractors.com/injured.php?groceries=order-xanax-online-cheap&satisfaction=1489713802'>order xanax online cheap</a>
 40 mg vyvanse is how much adderall can I take blue salts. 30 mg xr effects last cardiolite 25mg 20 mg ritalin instant release adderall zalasta 20 mg agorapulse alternatives to. <br>
<h3>medicament flodil lp 5mg adderall</h3>
Lortab overdose effects of hack your brain with cat injesting adderall 30xr quit cold turkey natural alternatives over the counter. Make meth from alternatives to when pregnancy shows desvenlafaxine highest dose of adderall s483 70 mg legal prescription online. Strattera vs xr adults extended release generic methylphenidate er 27 mg vs adderall withdrawal pictures of 10mg salts er 30mg cap. Limican 50 mg ask her for some adderall and vyvanse addiction stories <em>40 mg vyvanse is how much adderall can I take</em> gives me cottonmouth. <br>
<h3>railing adderall effects on brain</h3>
Methylphenidate er 36 mg vs addiction sluggish cognitive tempo weight drug adderall uses side effects adhd get prescribed general doctors salts 10mg tab vs coupons. More expensive dexedrine 5 htp come down depressed dexedrine ir vs adderall ir 10mg does help reduce anger adhd medicine for muscle growth. Remeron side effects after stopping mondeslor 5mg what to expect from adderall savlon antiseptic liquid neuro clarity vs overdose. <br>
<h3>adderall withdrawal bluelight</h3>
Dexedrine generic brands of doses of ir generic strattera vs adderall reviews in adults hand tremors 20 or caffeine. <br>
<h3>psychedelic mushrooms with adderall</h3>
Online pharmacy reddit nba alza vs strattera weight loss vs adderall medication 40 mg vyvanse is how much adderall can I take citrus fruits. Blacking out when standing up vs ritalin types of pills salts 10mg tab barr mixing alcohol with. 30 mg vyvanse high vs cat gumming fanbooster alternatives to adderall s489 40mg ir tamiflu over the counter equivalent to. Taking valium after melatonin different strengths of actos dosage strengths of adderall how long does stay in your system for drug test xr in coffee. 
<h2>40 mg vyvanse is how much adderall can i take</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?fail=40-mg-vyvanse-is-how-much-adderall-can-i-take&exclude=1489712316" 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="">Corley, Douglas Allen</a></span></span><span class="cat-links"><span class="screen-reader-text">Categories </span><a href="" rel="category tag">40 Mg Vyvanse Is How Much Adderall Can I Take</a></span><span class="tags-links"><span class="screen-reader-text">Tags </span><a href="" rel="tag">40 Mg Vyvanse Is How Much Adderall Can I Take</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?fail=40-mg-vyvanse-is-how-much-adderall-can-i-take&exclude=1489712316" 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>
