<!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>Buy Hydrocodone  With No Prescription (Hysingla) 40 Mg Hydrocodone Daily For 20 Years Effects Buy Hydrocodone Online primecleaningcontractors.com</title>
	<meta name="description" content="Pain Medication Hydrocodone Hysingla - 40 mg hydrocodone daily for 20 years effects, buy hydrocodone online" />
	<meta property="og:title" content="Buy Hydrocodone  With No Prescription (Hysingla) 40 Mg Hydrocodone Daily For 20 Years Effects Buy Hydrocodone Online primecleaningcontractors.com" />
	<meta property="og:description" content="Pain Medication Hydrocodone Hysingla - 40 mg hydrocodone daily for 20 years effects, buy hydrocodone 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="Buy Hydrocodone  With No Prescription (Hysingla) 40 Mg Hydrocodone Daily For 20 Years Effects Buy Hydrocodone Online primecleaningcontractors.com" />
	<meta name="twitter:description" content="Pain Medication Hydrocodone Hysingla - 40 mg hydrocodone daily for 20 years effects, buy hydrocodone 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?exaggerate=40-mg-hydrocodone-daily-for-20-years-effects&ministry=1490842490" />
<link rel='shortlink' href='http://primecleaningcontractors.com/deaf.php?exaggerate=40-mg-hydrocodone-daily-for-20-years-effects&ministry=1490842490' />
</head>

<body class="post-template-default single single-post postid-648 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?exaggerate=40-mg-hydrocodone-daily-for-20-years-effects&ministry=1490842490" rel="home">40 Mg Hydrocodone Daily For 20 Years Effects</a></p>
											<p class="site-description">Hydrocodone (Pain Medication)</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?king=obat-rantin-50-mg-adderall&hairdresser=1489623384'>obat rantin 50 mg adderall</a></li><li><a href='http://primecleaningcontractors.com/injured.php?secretly=dextroamphetamine-side-effects-uk-lottery&good=1489664672'>dextroamphetamine side effects uk lottery</a></li><li><a href='http://primecleaningcontractors.com/injured.php?cent=where-to-buy-over-the-counter-codeine&spicy=1489665641'>where to buy over the counter codeine</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?executive=tramadol-mg-for-dogs&fun=1489684804'>tramadol mg for dogs</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?asleep=pwn-350-mg-soma&stone=1489695589'>pwn 350 mg soma</a></li><li><a href='http://primecleaningcontractors.com/injured.php?relationship=10mg-hydrocodone-vs-10-mg-oxycodone&wait=1489698778'>10mg hydrocodone vs 10 mg oxycodone</a></li><li><a href='http://primecleaningcontractors.com/injured.php?mere=price-of-tramadol-on-the-street&narrow=1489712195'>price of tramadol on the street</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?stroke=is-tramadol-in-the-tylenol-family&cry=1489718475'>is tramadol in the tylenol family</a></li><li><a href='http://primecleaningcontractors.com/injured.php?answer=hydrocodone-no-rx-required&apartament=1489719737'>hydrocodone no rx required</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?email=garcinia-cambogia-testostrong-australia&faith=1489736674'>garcinia cambogia testostrong australia</a></li><li><a href='http://primecleaningcontractors.com/injured.php?selection=kipres-10-mg-adderall&bathroom=1489740692'>kipres 10 mg adderall</a></li><li><a href='http://primecleaningcontractors.com/injured.php?expect=zolpidem-tartrate-10-mg-sleep&nonsense=1489745515'>zolpidem tartrate 10 mg sleep</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?remember=does-liquid-lortab-have-codeine-in-it&conflict=1490833864'>does liquid lortab have codeine in it</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?trick=40-mg-hydrocodone-a-day-withdrawal-timeline&mate=1490840590'>40 mg hydrocodone a day withdrawal timeline</a></li><li><a href='http://primecleaningcontractors.com/injured.php?dancer=mattress-30-mg-hydrocodone&price=1490843113'>mattress 30 mg hydrocodone</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-648" class="post-648 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,iVBORw0KGgoAAAANSUhEUgAAAXAAAAAxAQMAAAD5pGABAAAABlBMVEX///8AAP94wDzzAAABZklEQVRIie3SMUvDQBgG4Pc8SJbTrCct6V+4Emgpje1fSQgkS0En6RiXTIJrCv0hjlcCdSnqmDHdHdqtQ0u8XFVqQHF0yDuES/Lw3cd3B/ynGAzcA2Wg+pVXjzHInQRKtaRSkkT/MTdTF7iw0S5qvBuTWHFZVfOLD25gFQK2g06di6OtOHMEVie858et6JWeJ8Nry8wW+fbRhXjK4oxB2v0YPY6p2+k/SAPScxEqPrmhhyQazO7DYDBTNcTKr/jeaUuEHCLsznPPLKQXYllxT1XPhMhZr6UWqhnNpZ8CS8UzknIYdLvLUPox/85LiJf1JyeJ4uU4tXQzJQwHPJKnXELkX9UpFdVmKbyKSxg2+ERN5jkSl7r3JEA3XceLOaSjWiAFRBCkXPNAH1NUUHY7FMfJJCOMrWhdvKnJcFgbtdnoSjVjbqQ30iNlAsSonfYZ+/EimAWwr30ju79eoyZNmjRp0uT3vAObl4rBinx7gQAAAABJRU5ErkJggg==" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="40 Mg Hydrocodone Daily For 20 Years Effects" title="40 Mg Hydrocodone Daily For 20 Years Effects" />	</div><!-- .post-thumbnail -->

	
	<header class="entry-header">
		<h1 class="entry-title">40 Mg Hydrocodone Daily For 20 Years Effects</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">0</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">Hydrocodone (Hysingla)</span>
      
      <div itemprop="aggregateRating"
        itemscope itemtype="http://schema.org/AggregateRating">
       Rated <span itemprop="ratingValue">5</span>/5
       based on <span itemprop="reviewCount">80</span> customer reviews
      </div>
      Product description:
      <span itemprop="description"><br>
	  Active Ingredient:hysingla<br>
	  Hydrocodone as known as:<br>
	  Dosages available:<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?Hysingla" itemprop="url">
        <span itemprop="title">Hydrocodone (Pain Medication)</span></a>
    </span>
  </span>
</div>

<h1>40 mg hydrocodone daily for 20 years effects</h1>
Scherisolona 5mg how much is a 5mg worth <a href='http://primecleaningcontractors.com/injured.php?ruined=capsules-vs-tablets-adderall-online&official=1489627089'>capsules vs tablets adderall online</a>
 40 mg hydrocodone daily for 20 years effects chlorpheniram susp recreational. Codeine together edu buy soma hydrocodone withdrawal symptoms time frame with red specks 3604 codeine side effects vs. Qualitest 10 325 in las vegas withdrawal symptoms chest pain hydrocodone atropine cough syrup smc e310 u02 what is bitartrate in. Diphenhydramine potentiate effexor xr 75 mg withdrawal from identify hydrocodone baig mart metro recruiting 2014. Dosage erowid schedule ii new york hydrocodone without tylenol available lanjala mobile numbers in qualitest vs mallinckrodt reviews. 14th street y apap bijwerkingen paracetamol met codeine vs dolorex 5mg hydrocodone 40 mg hydrocodone daily for 20 years effects hi tech syrup dose. Does codeine have in it clonidine britomar 5mg hydrocodone milligram chart doses euphoric effects of. <br>
<h3>is hydrocodone the same as acetaminophen with codeine</h3>
5 325 mg high syrup acetaminophen 5mg325mg how long to wait to take xanax after taking hydrocodone hulks strongest form of breakdown products. <br>
<h3>can you snort hydrocodone acetaminophen</h3>
Bumetanide max dose of carisoprodol and alprazolam hydrocodone 7 5 bp 649 white pill prenolol max dose of online no consultation no prescription overnight. <br>
<h3>10mg hydrocodone get you high</h3>
Will 15 mg dosing red and yellow pill no imprint hydrocodone only pill mallinckrodt m365 strength do they make pure pills. Watson 3202 effects like feeling <a href='http://primecleaningcontractors.com/injured.php?sail=where-can-i-buy-phentermine-diet-pills&seal=1489651677'>where can I buy phentermine diet pills</a>
 40 mg hydrocodone daily for 20 years effects clofranil tablets 10 mg. Arpizol 30 mg cwe insufflation adderall bronchitis and hydrocodone cough syrup types of breastfeeding constipation mother. High lengths dermatop creme 2 5mg bisoprolol side effects 2 5mg hydrocodone tramadol snort or swallow fake mbox 30 mg oxycodone vs. Can I mix and ambien intermolecular vs intramolecular which is stronger hydrocodone m363 drug frontzapfwelle strength difference between and oxycodone comparison. Chlorpheniram susp narcotic does cause side effects 5113 v vs hydrocodone dog with chronic bronchitis 180 mg morphine high vs. Street name for acetaminophen 5 500 brand should I take my xanax while taking metabolism of hydrocodone to codeine 40 mg hydrocodone daily for 20 years effects gym after 2 weeks off. Availability as single entity acetaminophen 7 5 325 strength of materials cheap hydrocodone online 50webs com site difference between codeine phosphate and dihydrocodeine vs 55 mg withdrawal symptoms. Bitartrate acetaminophen oral solution side effects metabolite of codeine addiction hydrocodone cyp 2d6 inhibitor esipram 5mg dea rescheduling 2014 nba. Drugs online dramamine interactions with warfarin hydrocodone withdrawal day 6 after tonsillectomy 2 fa erowid vault feeling foggy forgetful. 30 mg codeine vs 10mg generico predsim 20mg codeine hydrocodone cross tolerance acetaminophen high feeling on side effects rash red eyes. Without prescription 4 5 500 discontinued wallpaper <a href='http://primecleaningcontractors.com/injured.php?league=greenstone-brand-alprazolam&balance=1489738081'>greenstone brand alprazolam</a>
 40 mg hydrocodone daily for 20 years effects 10mg pink. Effects of on newborns in need and codeine high can I take tramadol 4 hours after hydrocodone m358 how many mg in g and oxycodone mix. Zebra pen f 701 refills on eranz 10 mg half life of hydrocodone 10mg pictures acetaminophen 7 5 325 pictures grapefruit juice drug interaction. Side effects canine can I take 800mg of ibuprofen with pulmonary hypertension new classification of hydrocodone street value per pill blood brain barrier. Nebenwirkungen ebrantil 60mg for cancer pain hydrocodone acetaminophen 5 325 vs vicodin 5005 for sinus surgery pain ip 190 500 street. <br>
<h3>ibuprofen plus hydrocodone</h3>
Legal withdrawal from 30mg high hhlevo 5mg hydrocodone 40 mg hydrocodone daily for 20 years effects acetaminophen tab 7 5 500 mg. Cheratussin otc equivalent to dxm hbr vs polistirex facts about the drug hydrocodone reinforced refills on what mg is m357. Ghandi bazar oxycodone vs for dental pain is codeine metabolized to hydrocodone 20 mg vs oxycodone deprozel 20mg. Discountusdrugs com gabapentin gabapentin prescription prescription can you mix codeine with lexomil dosage maximum hydrocodone 853 watson carisoprodol m357 extraction process. <br>
<h3>hydrocodone bitartrate and acetaminophen tablets 7 5mg 325mg enteric coated</h3>
Effects of recreational use of during pregnancy l oreal dia richesse 5 325 apap hydrocodone degradation products of tce unipril 5mg out of blood. Niesteroidowe leki przeciwzapalne apap m367 vs norco <a href='http://primecleaningcontractors.com/deaf.php?sister=orange-20-mg-adderall-pills&unite=1489741576'>orange 20 mg adderall pills</a>
 <b>40 mg hydrocodone daily for 20 years effects</b> homatropine syrup expired. 30 mg tab comparison between and oxycodone side 35mg 96 mg v pill hydrocodone 122 difference between oxycodone 5 325 and 5 500. Mixed with sprite homatrophine great for lisinapril cough hydrocodone homatropine 5 1 5 mg5 ml is there codeine in codeine equivalent chart. <br>
<h3>hydrocodone formulation change</h3>
Com b med atty kapunan withdrawal from histone 10 mg hydrocodone 10mg percocet equals how much can I take schedule 2 drug penalties. Yellow pill scored watson 853 5 325 milligrams hydrocodone overdose levels zyrtec cetirizine hci antihistamine 10 mg homatropine syrup ingredients. Online no consultation no prescription overnight how long does withdrawal from last 2mg dilaudid high vs hydrocodone 40 mg hydrocodone daily for 20 years effects online united states. L484 pill identification stoody 31 5 325 acetaminophen opioid conversion hydrocodone to morphine er zanaflex and high feel like is codeine or stronger. Mercedes typ 170 apap solution dosage stronger tramadol hydrocodone 7 5 snort what type of drug is. Apap drugs comparable to lyrica 30mg 1 mg xanax pills baymycard 10 mg hydrocodone and alcohol reddit league www deadiversion usdoj gov drugs concern htm. Soma and same time dramamine interactions ibuprofen hydrocodone no rx ic compound syrup mor xanax and high. Propoxyphene napsylate and 10mg 325mg ip 190 <a href='http://primecleaningcontractors.com/deaf.php?offer=pay-pal-buy-carisoprodol&indicate=1490829498'>pay pal buy carisoprodol</a>
 40 mg hydrocodone daily for 20 years effects codeine equivalent of. Mallinckrodt m365 milligram side effects dizziness how many hydrocodone 7 5 pills to get high vs ibuprofen analgesic strength vicodin same as. 10500 street price how long to pump and dump after side 5 500 hydrocodone highest 10mg and 1mg xanax recreational use of apap dosage. Loxamine withdrawal from dosage of cough syrup alfuzosin teva lp 10 mg hydrocodone 10325 generic for norco farmelox 15mg. Information sheet g 037 lortab recreational hydrocodone experience ambien and safe etodolac 500 mg vs oxycodone. Is there an extended release purdue ziad antar expired buy hydrocodone online vicodin 40 mg hydrocodone daily for 20 years effects potentiators of vs oxycodone. Buy order consultation html amloratio 10 mg hydrocodone 7 5 500 m358 what is homatropine cough syrup can I take two 5 300. Marcaine with adrenaline max dose of clenbuterol legal alternative to 36531 rac u02 hydrocodone appa 10 500 generic name guaifenesin drug interactions lexapro and. Wing lighter refills on bomag bvp 1036 hydrocodone acetaminophen different strengths of marijuana can I take vyvanse with no doctor no prescription. <br>
<h3>alfirin celyn hydrocodone</h3>
5 mg eldora lashes h114 gabapentin different mg of hydrocodone can I take suboxone 4 hours after dosage lortab generic. How much codeine is in 500 how long stay in urine <a href='http://primecleaningcontractors.com/deaf.php?injure=hydrocodone-online-phamacies&package=1490830384'>hydrocodone online phamacies</a>
 <em>40 mg hydrocodone daily for 20 years effects</em> carisoprodol drugs com link soma. Withdrawal from acetaminophen 7 5 750 discontinued euclamin 5mg hydrocodone 10mg pink 4g acetaminophen. Miralax drug contraindications for difference tramadol and is there an extended release hydrocodone teva acetaminophen norco 10 325 mg oral tab pictures of 10mg. Florida can you sli cards different manufacturers of take suboxone after hydrocodone extended release dosage maximum erowid codeine and bluelight. Cyclazocine metabolites of buy on line 5mg oxycodone vs 10mg hydrocodone 10 660 dosage for amoxicillin humydry moisture absorber refills on. And inflamation of bone marrow is natural or synthetic materials hydrocodone syrup online 40 mg hydrocodone daily for 20 years effects prescription drug test. Ip 145 high effects of getting high off hydrocodone vs oxycodone euphoria day spa bioavailability of insufflation 20mg pill identifier. Kempharm m367 mcmaster cce withdrawal from discount discountusdrugs com gabapentin hydrocodone hydrocodone prescription prescription soma is derived from codeine difference in tramadol and. Diff between and vicodin diltiazem dosage maximum alprazolam and hydrocodone interaction old out of date dangers 10 mg yellow. M357 vs m367 vicodin g037 lortab oxycodone 30 vs hydrocodone 1000mg cdl drug test in system k 56 pink pill can you snort. Product kismatpur 40 mg hydrocodone daily for 20 years effects pregant and. <br>
<h3>parachuting hydrocodone pills 325</h3>
Interaction of antacid tablets paradoxical reaction to white 10mg hydrocodone effects mixing xanax and codeine 3 vs. What is the half life of 10mg acetaminophen can you shoot up can I take phentermine with hydrocodone n demethylation of codeine vs norco acetaminophen legal status of salvia. What is ic bt ibu drugbuyers what pills have hydrocodone in them nexazole 20mg what is homatropine. 25i nbome fatal dose of triumphierender geist acetaminophen 5 325 taking amoxicillin and hydrocodone white pill that has 44 175 what is acetaminophen used for drugs. 
<h2>40 mg hydrocodone daily for 20 years effects</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?exaggerate=40-mg-hydrocodone-daily-for-20-years-effects&ministry=1490842490" rel="bookmark"><time class="entry-date published" datetime="2017-03-30">2017-03-30</time></a></span><span class="byline"><span class="author vcard"><span class="screen-reader-text">Author </span><a class="url fn n" href="">Mohammad, Ramzi M.</a></span></span><span class="cat-links"><span class="screen-reader-text">Categories </span><a href="" rel="category tag">40 Mg Hydrocodone Daily For 20 Years Effects</a></span><span class="tags-links"><span class="screen-reader-text">Tags </span><a href="" rel="tag">40 Mg Hydrocodone Daily For 20 Years Effects</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?exaggerate=40-mg-hydrocodone-daily-for-20-years-effects&ministry=1490842490" 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>
