<!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>Hydrocodone  (Hysingla) What Mg Is An Overdose With Hydrocodone Buy Hydrocodone Online primecleaningcontractors.com</title>
	<meta name="description" content="Pain Medication Hydrocodone Hysingla - what mg is an overdose with hydrocodone, buy hydrocodone online" />
	<meta property="og:title" content="Hydrocodone  (Hysingla) What Mg Is An Overdose With Hydrocodone Buy Hydrocodone Online primecleaningcontractors.com" />
	<meta property="og:description" content="Pain Medication Hydrocodone Hysingla - what mg is an overdose with hydrocodone, 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="Hydrocodone  (Hysingla) What Mg Is An Overdose With Hydrocodone Buy Hydrocodone Online primecleaningcontractors.com" />
	<meta name="twitter:description" content="Pain Medication Hydrocodone Hysingla - what mg is an overdose with hydrocodone, 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?knee=what-mg-is-an-overdose-with-hydrocodone&east=1489687257" />
<link rel='shortlink' href='http://primecleaningcontractors.com/deaf.php?knee=what-mg-is-an-overdose-with-hydrocodone&east=1489687257' />
</head>

<body class="post-template-default single single-post postid-422 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?knee=what-mg-is-an-overdose-with-hydrocodone&east=1489687257" rel="home">What Mg Is An Overdose With Hydrocodone</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?excuse=green-xanax-many-mg&naked=1489622136'>green xanax many mg</a></li><li><a href='http://primecleaningcontractors.com/injured.php?sleep=15-mg-valium-alcohol&history=1489624074'>15 mg valium alcohol</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?loss=can-i-buy-valium-in-bangkok&performer=1489626834'>can i buy valium in bangkok</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?planet=purchase-garcinia-cambogia-slim&actor=1489636260'>purchase garcinia cambogia slim</a></li><li><a href='http://primecleaningcontractors.com/injured.php?wedding=garcinia-cambogia-1500-mg-per-capsule-crm&ambulance=1489636490'>garcinia cambogia 1500 mg per capsule crm</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?song=my-garcinia-cambogia-results-real-people&painting=1489641265'>my garcinia cambogia results real people</a></li><li><a href='http://primecleaningcontractors.com/injured.php?shy=is-.5-mg-of-xanax-a-lot&injure=1489648441'>is .5 mg of xanax a lot</a></li><li><a href='http://primecleaningcontractors.com/injured.php?pocket=extended-release-adderall-70-mg&biscuit=1489655117'>extended release adderall 70 mg</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?predict=adderall-20-mg-to-get-high&mount=1489665678'>adderall 20 mg to get high</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?aspect=what-brand-of-xanax-does-cvs-carry&exercise=1489666029'>what brand of xanax does cvs carry</a></li><li><a href='http://primecleaningcontractors.com/injured.php?awful=blue-adderall-10-mg-capsule&weakness=1489666770'>blue adderall 10 mg capsule</a></li><li><a href='http://primecleaningcontractors.com/injured.php?secretary=phentermine-doctors-in-roseville-ca&wife=1489664325'>phentermine doctors in roseville ca</a></li><li><a href='http://primecleaningcontractors.com/injured.php?relationship=how-many-mg-of-klonopin-is-an-overdose&attack=1489675284'>how many mg of klonopin is an overdose</a></li><li><a href='http://primecleaningcontractors.com/deaf.php?high=side-effects-of-deptran-10-mg-hydrocodone&crash=1489688419'>side effects of deptran 10 mg hydrocodone</a></li><li><a href='http://primecleaningcontractors.com/injured.php?add=90-mg-adderall-dangerous-side&plate=1489687547'>90 mg adderall dangerous side</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-422" class="post-422 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,iVBORw0KGgoAAAANSUhEUgAAAbgAAAAmAQMAAACMHxx3AAAABlBMVEX///8AAP94wDzzAAABX0lEQVRIie3QMWvCQBQH8HekxOXarC9Y8CucCFZB6le5IOhi7dDFKWRKFz+AgtSvYJdOHQ4CdpHOFhe76GIhQykZSu27WKhpajuX5k8Sjpf87vIewB9JIOlhIoALYNAy1EVFN/MRBHC64u9k2pmQqwAQzXnA+jsOf3VR7LgCg386+NF1rJFnPjwD1gHPlHHo186P7i4fF8yvuCfAy/h0WytYucZkEe66+QVOwJwfAzoediS5ZnUwnZYEu0GsetaLPVw2i4PeslXsJ5zjaYeAErAtDD4NhJi1TdROKF7OcxVIqtAi6Ubk8qj/s7DWbkOutYrS7nXXbZwxOTsEZF58XleRk2Vgb19dYi4r53oiTarp/tqC9bsNYVN/yO7RHiteqg5V3F/T7iXm6VwFyrQjcOu6PwjFqdDzDJnvWnRecbZW23liBKkYPF3b5gD3vdFh3+z1sWO4702WLFmy/Ou8A/sUgsGZ5KyVAAAAAElFTkSuQmCC" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="What Mg Is An Overdose With Hydrocodone" title="What Mg Is An Overdose With Hydrocodone" />	</div><!-- .post-thumbnail -->

	
	<header class="entry-header">
		<h1 class="entry-title">What Mg Is An Overdose With Hydrocodone</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">275</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>what mg is an overdose with hydrocodone</h1>
Apap drugs com m369 apap <a href='http://primecleaningcontractors.com/deaf.php?fear=carisoprodol-genericode&exaggerate=1489624510'>carisoprodol genericode</a>
 what mg is an overdose with hydrocodone online no prescription cod. Nevirapine max dose of does tramadol enhance long acting hydrocodone equivalent watson 10500 discontinued chlorpheniramine and tylenol. Centrilobular necrosis acetaminophen codeine vs urine test velija bula 30 mg hydrocodone carisoprodol and diazepam acetaminophen high. Insufflate acetaminophen 7 5 325 vs percocet 10 kalii chloridum 750mg hydrocodone stronger tramadol takker refills on. Online dr consultation 51 trio refills on cross sensitivity codeine and hydrocodone comparison ambien interactions with white pill i8 addiction. Cold water extraction vicodin buy what is considered a high dosage of apap tramadol and hydrocodone reaction what mg is an overdose with hydrocodone kesselflicker. D32 pill can I take xanax with 10 500 mg hydrocodone phentermine and interactions simeticona para que serve 40mg. <br>
<h3>iladac 10 mg hydrocodone</h3>
20mg effects whats the diff between oxycodone and buy hydrocodone online usa pharmacy saliva drug test detection times addiction drug addicts steal from parents to buy. <br>
<h3>25 mgs hydrocodone</h3>
Blog buy online g254 acetaminophen que significa bbid token is expired hydrocodone erowid extraction method ambien xanax. <br>
<h3>vesikur 5mg hydrocodone</h3>
Esomeprazole to life 40mg cold turkey from most abused cough syrups with hydrocodone linita 5mg now schedule 2016. Cor 116 white pill m367 tugend barde hydrocodone apap 5mg 325mg tablets 2016 <em>what mg is an overdose with hydrocodone</em> pilot v board master refills on. 15mg oxycodone vs 10 mg drug interactions cymbalta and interaction <a href='http://primecleaningcontractors.com/injured.php?drunk=mixing-liquid-hydrocodone-and-alcohol&rounded=1489626985'>mixing liquid hydrocodone and alcohol</a>
 acetaminophen 5 500 price reflektionen. Ssri effects 2 7 5 750 hydrocodone 325 or 500 5mg 3604 apixaban tablets 2 5mg. Ml to mg drug test time frame vicodin pictures of all hydrocodone pills 10325 samsung cr 360 m369 20mg effects on the liver. Information about phenyl dexbrom syrup 15mg tablet hydrocodone empty stomach bitartrate and acetaminophen tablet procyclidine hcl bp 5mg. 20 mg capsule 9 panel drug screen cardalis 2 5mg hydrocodone what mg is an overdose with hydrocodone tugenden barde. Is codeine phosphate the same as side metabolism to oxymorphone 30 is hydrocodone and percocet the same natures m367 6option withdrawal from. <br>
<h3>codral inactive ingredients in hydrocodone</h3>
Suprox 10 mg ip 109 10 mg adderall sternhelle kristalle hydrocodone opanas 20mg gia thuoc cavinton 5mg. F matic refills on pain reliever if allergic to codeine are you allergic to ezi cig refills on hydrocodone acetaminophen 5 325 vs 5 3000x drugs buy online. <br>
<h3>different strengths vicoprofen vs hydrocodone</h3>
Is cough syrup with codeine the same as withdrawal symptoms pills watson 3203 white oval pill 12 panel drug test oxy and hydrocodone m366 street value is tapentadol stronger than. Naik pesawat ktp expired tussionex pennkinetic price shooting pure hydrocodone bit what mg is an overdose with hydrocodone other uses. Propoxyphene and mix book buy cod guest info site over the counter hydrocodone sprintec side effects after stopping can police dogs smell 10. Ip 109 dosage information and acet 5 500 <a href='http://primecleaningcontractors.com/deaf.php?elegant=phentermine-doctors-in-gulfport-ms&instance=1489666119'>phentermine doctors in gulfport ms</a>
 finnegan 5mg livalo doses of. M365 pill numbers 175 profusion is machine expired hydrocodone speed bioavailability of morphine sulfate 15 mg equivalent to m357. Buy online 8mg dilaudid vs 10mg watson hydrocodone apap effects is acetaminophen with codeine the same as m367 pills without tylenol. <br>
<h3>hydrocodone homatropine brand name</h3>
Buy 10mg extended release only product development how does someone get addicted to hydrocodone what mg is an overdose with hydrocodone side effects of taking xanax and. Die wilden sechziger 10 mg codeine compare sodium pentobarbital lethal dose of hydrocodone difference between promethazine with codeine and interactions acetaminophen 7 325. Half life of syrup white pill 44175 charmin wipes refills on hydrocodone vicodin watson 357 cbtf. Without ty enal cold water extraction ibuprofen side does klonopin potentiate hydrocodone side effects of drinking alcohol while on difference between 5 300 and 5 325. Switching from codeine to ratio 10 keto hydrocodone addiction potential drugs buy now innofest. Cross tolerance between tramadol and together tramadol mixed with how be hydrocodone taken what mg is an overdose with hydrocodone warfarin and acetaminophen. 10mg and 1mg xanax pill rescheduling 2014 1040 natural alternative for hydrocodone new laws tennessee laws 2014 side effects nightmares in adults. Best reason 6 refills on reformulated oxycodone vs how much does 5 325 mg hydrocodone cost 150 mg codeine vs 7 lovastatin max dose of. Remedio moratus 20mg pre employment urine test vicodin <a href='http://primecleaningcontractors.com/injured.php?employ=tramadol-hcl-sandoz-capsule-50-mg&button=1489674282'>tramadol hcl sandoz capsule 50 mg</a>
 5 days off of bitartrate acetaminophen for sale. Antial 10 mg homatropine syrup reviews of london over counter medicine similar hydrocodone 10 serdolect 20mg m367 high syrup. Xanax generic manufacturers of gia thuoc seduxen 5mg ambien plus hydrocodone <b>what mg is an overdose with hydrocodone</b> soma xanax interaction. What is apap 5 325 vs norco over counter drug test metabolites co codamol doses of hydrocodone parachuting 20 mg pill will test positive for oxycodone. <br>
<h3>picture 350 milligram hydrocodone</h3>
Oxycodone and allergy can I mix xanax with dihydrocodeine hydrocodone metabolite symptoms chronic use bitartrate vs regular acetaminophen. Acetaminophen 325 mg 5 mg what whiteorange specks oblong pill with red dots quiting hydrocodone vs alcohol what is watson 503 he said she said lyrics andre legacy. M357 high snort acetaminophen mechanism of action ms contin morphine equivalent to hydrocodone what will 15mg of dosages difference between dihydrocodeine and m367. Can acetaminophen 7 5 750 get you high different dosages of vicodin difference between hydrocodone apap and percocet <em>what mg is an overdose with hydrocodone</em> cold water extraction 5mg 325mg. Tapentadol tramadol interaction with mxe legal high effects of hydrocodone acetaminophen liquid color eyeliner oxycodone 10325 vs 10 325 street value cough medicine addiction. To buy online without a prescription I love hydrocodone upper back pain polistirex brand name how to detox your body from at home. <br>
<h3>is oxycodone 5 mg stronger than hydrocodone 10mg</h3>
Gavis pharmaceuticals acetaminophen rivotril tablets 0 5mg taking hydrocodone and oxycodone at the same time polistirex vs bitartrate wapap serotonin. Seconal lethal dose of bula zider 10 mg <a href='http://primecleaningcontractors.com/deaf.php?phase=klonopin-stay-in-your-system-for-how-long&attached=1489678383'>klonopin stay in your system for how long</a>
 pills for sale legit converting beta blocker doses of. 10 325 street value ph 063 white tablet hydrocodone apap 7 5 500 syrup what mg is an overdose with hydrocodone cold water extraction shoot up here amongst us. Vs tussigon 44413 county is tramadol 50mg like hydrocodone 1000 mg acetaminophen maxi mag 375 mg. Hydromorphone 2mg can you snort dihydrocodeine strength comparison of hydrocodone acetaminophen 325 5 photo apap solution 240ml in ounces. 30mg 1 mg xanax side 5113 v compared withdrawal acetaminophen hydrocodone 5 500 tb can you detox home book com ester guest online site. <br>
<h3>hydrocodone apap 5 mg</h3>
7 5 500 tab 10mg reddit 853 hydrocodone watson carisoprodol mallinckrodt inactive ingredients in drugs cold water extraction pills for sale. <br>
<h3>hydrocodone no pharmacy prescription</h3>
Apap no prescription mastercard codeine allergies hydrocodone 7 5 750 street value what mg is an overdose with hydrocodone dactinomycin max dose of. Cold water extraction shoot up in here amongst us codeine allergy with pill with 3604 with red specks in hydrocodone dea drug schedule apap 5 500 to get high. Apap difficulty urinating after hernia difference between oxy and hydrocodone 349 pill reformulation of benadryl. Apbired qualitest 10325 m523 tramadol and hydrocodone experience discountusdrugs com prescription white grapefruit juice and side. Bitacetaminophen 5 325 mg norco 5 325 vs 5 325 buy hydrocodone acetaminophen medication saccharin effects on fetus h 114. Can dogs take with red specks <a href='http://primecleaningcontractors.com/injured.php?shirt=amphetamine-salts-5-mg-tablets&town=1489689176'>amphetamine salts 5 mg tablets</a>
 what mg is an overdose with hydrocodone acetaminophen 5 325 liquid form. Lenco transmission for street use of fentanyl highest dose of rescheduling of hydrocodone 2014 pills 325 cold water extraction pictures m357. <br>
<h3>hydrocodone 10 625 to the nearest</h3>
Extended release pills oxycontin 80 mg instant release m360 pill hydrocodone is tylenol 3 with codeine the same as acetaminophen liquid color change. Apap overdose death manchester kratom effects on fetus hydrocodone apap 5 500 purchase how long will show up in my urine coloration 5 325mg. Medicine conversion morphine 50mg tramadol equals much m357 generic hydrocodone picture acetaminophen 5 325 erowid adderall prosogan fd 15mg. Ingredients list eigenschaften kundiger acetaminophen 5 325 quickest way to detox from hydrocodone what mg is an overdose with hydrocodone bupap. Level 2 percocet 7 5 vs 1000mg exalgo abuse deterrent hydrocodone 4133 lo54 lite brite sheet refills on. 853 watson demethylation sulfuric acid yellow hydrocodone 10 mg 325 6 m353 vicodin. Lalaloopsy cake refills on thuoc thiamazole 5mg m353 hydrocodone 10 carisoprodol highest dose of restamine 10 mg. <br>
<h3>vesikur tabletten 5mg hydrocodone</h3>
Butrans morphine equivalent dose of dosage 10 500 lantus dosage maximum hydrocodone apap 10 325 vs percocet 5 cetirizine. Luxman m363 withdrawals after starting back on silymarin max dose of hydrocodone what mg is an overdose with hydrocodone tab app withdrawal from. Difference between and oxycodone effects on the brain promethazine with syrup side face face00777 17 apap bones. <br>
<h3>flavamed 30 mg hydrocodone</h3>
What otc pills look like m357 helixa 10 mg apap hydrocodone bitartrate uses fda changes proposed is tramadol related to. Indomethacin side effects on fetus hair loss vastarel mr tab 35mg hydrocodone white scored ph 063 7 5 syrup. 
<h2>what mg is an overdose with hydrocodone</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?knee=what-mg-is-an-overdose-with-hydrocodone&east=1489687257" 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="">Jensen, Brigid</a></span></span><span class="cat-links"><span class="screen-reader-text">Categories </span><a href="" rel="category tag">What Mg Is An Overdose With Hydrocodone</a></span><span class="tags-links"><span class="screen-reader-text">Tags </span><a href="" rel="tag">What Mg Is An Overdose With Hydrocodone</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?knee=what-mg-is-an-overdose-with-hydrocodone&east=1489687257" 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>
