<!doctype html>
<html>
<head>
	<meta charset="utf-8">
	<meta http-equiv="X-UA-Compatible" content="IE=edge">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">

	<link rel="stylesheet" href="css/vendor/fluidbox.min.css">
	<style type="text/css">
	.fluidbox{outline:0}.hidden{display:none}.fluidbox-overlay{background-color:rgba(255,255,255,.85);cursor:pointer;cursor:-webkit-zoom-out;cursor:-moz-zoom-out;opacity:0;position:fixed;top:0;left:0;bottom:0;right:0;transition:all .25s ease-in-out}.fluidbox-wrap{background-position:center center;background-size:cover;margin:0 auto;position:relative;transition:all .25s ease-in-out}.fluidbox-ghost{background-size:cover;background-position:center center;position:absolute;transition:all .25s ease-in-out}.fluidbox-closed .fluidbox-ghost{-webkit-transition-property:top,left,opacity,-webkit-transform;-moz-transition-property:top,left,opacity,-moz-transform;-o-transition-property:top,left,opacity,-o-transform;transition-property:top,left,opacity,transform;transition-delay:0,0,.25s,0}.fluidbox-closed .fluidbox-wrap img{transition-property:opacity;transition-delay:.25s;transition-duration:0s}
	
	</style>
	<style type="text/css">
	html, body, div, span, object, iframe,
h1, h2, h3, h4, h5, h6, p, blockquote, pre,
abbr, address, cite, code,
del, dfn, em, img, ins, kbd, q, samp,
small, strong, sub, sup, var,
b, i,
dl, dt, dd, ol, ul, li,
fieldset, form, label, legend,
table, caption, tbody, tfoot, thead, tr, th, td,
article, aside, canvas, details, figcaption, figure,
footer, header, hgroup, menu, nav, section, summary,
time, mark, audio, video {
  margin: 0;
  padding: 0;
  border: 0;
  outline: 0;
  vertical-align: baseline;
  background: transparent;
}

html, body {
  font-size: 100%;
}

article, aside, details, figcaption, figure, footer, header, hgroup, nav, section {
  display: block;
}

audio, canvas, video {
  display: inline-block;
}

audio:not([controls]) {
  display: none;
}

[hidden] {
  display: none;
}

html {
  font-size: 100%;
  -webkit-text-size-adjust: 100%;
  -ms-text-size-adjust: 100%;
}

html, button, input, select, textarea {
  font-family: sans-serif;
}

a:focus {
  outline: thin dotted;
  outline: 5px auto -webkit-focus-ring-color;
  outline-offset: -2px;
}
a:hover, a:active {
  outline: 0;
}

abbr[title] {
  border-bottom: 1px dotted;
}

b, strong {
  font-weight: bold;
}

blockquote {
  margin: 1em 40px;
}

dfn {
  font-style: italic;
}

mark {
  background: #ff0;
  color: #000;
}

pre, code, kbd, samp {
  font-family: monospace, serif;
  _font-family: 'courier new', monospace;
  font-size: 1em;
}

pre {
  white-space: pre;
  white-space: pre-wrap;
  word-wrap: break-word;
}

blockquote, q {
  quotes: none;
}
blockquote:before, blockquote:after, q:before, q:after {
  content: '';
  content: none;
}

small {
  font-size: 75%;
}

sub, sup {
  font-size: 75%;
  line-height: 0;
  position: relative;
  vertical-align: baseline;
}

sup {
  top: -0.5em;
}

sub {
  bottom: -0.25em;
}

nav ul, nav ol {
  list-style: none;
  list-style-image: none;
}

img {
  border: 0;
  height: auto;
  max-width: 100%;
  -ms-interpolation-mode: bicubic;
}

svg:not(:root) {
  overflow: hidden;
}

fieldset {
  border: 1px solid #c0c0c0;
  margin: 0 2px;
  padding: 0.35em 0.625em 0.75em;
}

legend {
  border: 0;
  padding: 0;
  white-space: normal;
}

button, input, select, textarea {
  font-size: 100%;
  margin: 0;
  vertical-align: baseline;
}

button, input {
  line-height: normal;
}

button, input[type="button"], input[type="reset"], input[type="submit"] {
  cursor: pointer;
  -webkit-appearance: button;
}

button[disabled], input[disabled] {
  cursor: default;
}

input[type="checkbox"], input[type="radio"] {
  box-sizing: border-box;
  padding: 0;
}

input[type="search"] {
  -webkit-appearance: textfield;
  -moz-box-sizing: content-box;
  -webkit-box-sizing: content-box;
  box-sizing: content-box;
}

input[type="search"]::-webkit-search-decoration, input[type="search"]::-webkit-search-cancel-button {
  -webkit-appearance: none;
}

button::-moz-focus-inner, input::-moz-focus-inner {
  border: 0;
  padding: 0;
}

textarea {
  overflow: auto;
  vertical-align: top;
}

table {
  border-collapse: collapse;
  border-spacing: 0;
}

/* Neat 1.7.0
 * http://neat.bourbon.io
 * Copyright 2012-2014 thoughtbot, inc.
 * MIT License */
html {
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  box-sizing: border-box;
}

*, *:before, *:after {
  -webkit-box-sizing: inherit;
  -moz-box-sizing: inherit;
  box-sizing: inherit;
}

body {
  -webkit-font-feature-settings: "kern", "liga", "frac", "pnum";
  -moz-font-feature-settings: "kern", "liga", "frac", "pnum";
  -ms-font-feature-settings: "kern", "liga", "frac", "pnum";
  font-feature-settings: "kern", "liga", "frac", "pnum";
  -webkit-font-smoothing: antialiased;
  text-rendering: optimizeLegibility;
  background-color: #22272a;
  color: #ced9e0;
  font-family: "font-family: " Helvetica Neue ",Helvetica,Arial,sans-serif";
  font-size: 1em;
  line-height: 1.5;
}

h1,
h2,
h3,
h4,
h5,
h6 {
  font-family: "font-family: " Helvetica Neue ",Helvetica,Arial,sans-serif";
  line-height: 1.25;
  margin: 0;
  color: #fff;
}

h1 {
  font-size: 2.25em;
}

h2 {
  font-size: 2em;
}

h3 {
  font-size: 1.75em;
}

h4 {
  font-size: 1.5em;
}

h5 {
  font-size: 1.25em;
}

h6 {
  font-size: 1em;
}

p {
  margin: 0 0 0.75em;
  font-family: "font-family: " Helvetica Neue ",Helvetica,Arial,sans-serif";
}

a {
  -webkit-transition: color 0.1s linear;
  -moz-transition: color 0.1s linear;
  transition: color 0.1s linear;
  color: #ced9e0;
  text-decoration: none;
}
a:hover {
  color: #9fb5c2;
  border-color: #9fb5c2;
}
a:active, a:focus {
  color: #9fb5c2;
  border-color: #9fb5c2;
  outline: none;
}

header {
  color: #fff;
}

hr {
  border-bottom: 1px solid #ddd;
  border-left: none;
  border-right: none;
  border-top: none;
  margin: 1.5em 0;
}

img,
picture {
  margin: 0;
  max-width: 100%;
}

blockquote {
  border-left: 2px solid #ddd;
  color: #fdfdfe;
  margin: 1.5em 0;
  padding-left: 0.75em;
}

cite {
  color: white;
  font-style: italic;
}
cite:before {
  content: "\2014 \00A0";
}

body {
  padding-left: 1em;
  padding-right: 1em;
}

a {
  border-bottom: 1px solid #ced9e0;
}

a:hover {
  color: #e85151;
}

header {
  max-width: 68em;
  margin-left: auto;
  margin-right: auto;
  margin-top: 4em;
  border-top: 2px solid #e85151;
  opacity: 0;
  -webkit-transform: translateY(50px);
  -moz-transform: translateY(50px);
  -ms-transform: translateY(50px);
  -o-transform: translateY(50px);
  transform: translateY(50px);
  -webkit-transition: all 1200ms ease;
  -moz-transition: all 1200ms ease;
  transition: all 1200ms ease;
  -webkit-transition-delay: 50ms;
  -moz-transition-delay: 50ms;
  transition-delay: 50ms;
}
header:after {
  content: "";
  display: table;
  clear: both;
}
@media screen and (max-width: 540px) {
  header {
    margin-top: 2em;
  }
}
header #logo-container {
  float: left;
  display: block;
  margin-right: 2.35765%;
  width: 48.82117%;
}
header #logo-container:last-child {
  margin-right: 0;
}
@media screen and (max-width: 540px) {
  header #logo-container {
    float: left;
    display: block;
    margin-right: 7.42297%;
    width: 100%;
  }
  header #logo-container:last-child {
    margin-right: 0;
  }
}
header #logo-container #logo {
  padding-top: 0.5em;
  font-weight: bold;
  font-size: 48px;
  line-height: 60px;
  letter-spacing: -0.05em;
  float: none;
}
header #logo-container #subtitle {
  color: #e85151;
  font-weight: bold;
  font-size: 18px;
}
header a {
  color: #e85151;
  text-decoration: none;
  border: none;
}
header a:hover {
  color: #d11c1c;
  border-color: #d11c1c;
}
header a:active, header a:focus {
  color: #d11c1c;
  border-color: #d11c1c;
}
header nav {
  text-align: right;
  float: left;
  display: block;
  margin-right: 2.35765%;
  width: 74.41059%;
}
header nav:last-child {
  margin-right: 0;
}
@media screen and (max-width: 540px) {
  header nav {
    text-align: left;
    margin-top: 1em;
    float: left;
    display: block;
    margin-right: 7.42297%;
    width: 100%;
  }
  header nav:last-child {
    margin-right: 0;
  }
}
header nav ul {
  padding-top: 0.5em;
  line-height: 60px;
}
header nav ul li {
  display: inline-block;
  margin-left: 1em;
}
@media screen and (max-width: 540px) {
  header nav ul li {
    margin-left: 0;
    margin-right: 1em;
  }
}
header nav ul li a {
  font-weight: bold;
}
header nav ul li a.bordered {
  border-radius: 0.2em;
  padding: 0.4em;
  padding-left: 0.8em;
  padding-right: 0.8em;
  border: 2px solid #e85151;
}

#content {
  max-width: 68em;
  margin-left: auto;
  margin-right: auto;
  padding-bottom: 2em;
  opacity: 0;
  -webkit-transform: translateY(50px);
  -moz-transform: translateY(50px);
  -ms-transform: translateY(50px);
  -o-transform: translateY(50px);
  transform: translateY(50px);
  -webkit-transition: all 1200ms ease;
  -moz-transition: all 1200ms ease;
  transition: all 1200ms ease;
  -webkit-transition-delay: 350ms;
  -moz-transition-delay: 350ms;
  transition-delay: 350ms;
}
#content:after {
  content: "";
  display: table;
  clear: both;
}
#content section.intro {
  max-width: 68em;
  margin-left: auto;
  margin-right: auto;
  margin-bottom: 5em;
}
#content section.intro:after {
  content: "";
  display: table;
  clear: both;
}
@media screen and (max-width: 540px) {
  #content section.intro {
    margin-bottom: 1em;
  }
}
#content section.intro h1 {
  font-size: 8em;
  border-top: 2px solid #fff;
  letter-spacing: -0.05em;
  margin-top: 1.2em;
  margin-bottom: 1em;
}
@media screen and (max-width: 540px) {
  #content section.intro h1 {
    font-size: 4em;
    line-height: 1.2em;
    padding-top: 0.4em;
  }
}
#content section.intro h1 span.nl {
  display: none;
}
@media screen and (max-width: 540px) {
  #content section.intro h1 span.nl {
    display: block;
  }
}
#content section.intro p {
  font-size: 2.0em;
  line-height: 1.5em;
  letter-spacing: 0.02em;
}
#content section.row {
  max-width: 68em;
  margin-left: auto;
  margin-right: auto;
  padding-top: 2em;
  padding-bottom: 5em;
}
#content section.row:after {
  content: "";
  display: table;
  clear: both;
}
#content section.row h2 {
  text-transform: uppercase;
  font-size: 1.0em;
  font-weight: bold;
  color: #e85151;
  margin-bottom: 0.05em;
}
#content section.row p {
  font-size: 1.2em;
  line-height: 1.6em;
}
#content section.row .col, #content section.row .col-full {
  float: left;
  display: block;
  margin-right: 2.35765%;
  width: 48.82117%;
  border-top: 2px solid #ced9e0;
  padding-top: 1em;
  padding-bottom: 3em;
}
#content section.row .col:last-child, #content section.row .col-full:last-child {
  margin-right: 0;
}
@media screen and (max-width: 540px) {
  #content section.row .col, #content section.row .col-full {
    float: left;
    display: block;
    margin-right: 7.42297%;
    width: 100%;
  }
  #content section.row .col:last-child, #content section.row .col-full:last-child {
    margin-right: 0;
  }
}
#content section.row .col-full {
  float: left;
  display: block;
  margin-right: 2.35765%;
  width: 100%;
}
#content section.row .col-full:last-child {
  margin-right: 0;
}
@media screen and (max-width: 540px) {
  #content section.row .col-full {
    float: left;
    display: block;
    margin-right: 7.42297%;
    width: 100%;
  }
  #content section.row .col-full:last-child {
    margin-right: 0;
  }
}
#content .photo-grid {
  display: -webkit-box;
  display: -moz-box;
  display: box;
  display: -webkit-flex;
  display: -moz-flex;
  display: -ms-flexbox;
  display: flex;
  -webkit-flex-flow: row wrap;
  -moz-flex-flow: row wrap;
  flex-flow: row wrap;
  -webkit-box-pack: justify;
  -moz-box-pack: justify;
  box-pack: justify;
  -webkit-justify-content: space-between;
  -moz-justify-content: space-between;
  -ms-justify-content: space-between;
  -o-justify-content: space-between;
  justify-content: space-between;
  -ms-flex-pack: justify;
}
#content .photo-grid a {
  margin-bottom: 20px;
  border: none;
  text-decoration: none;
}
#content .photo-grid a.col-1 {
  width: 100%;
}
#content .photo-grid a.col-2 {
  width: 49%;
  width: calc(50% - 12px);
}
#content .photo-grid a.col-3 {
  width: 32%;
  width: calc(33.33333% - 16px);
}
@media screen and (max-width: 540px) {
  #content .photo-grid a {
    margin-bottom: 10px;
  }
  #content .photo-grid a.col-2 {
    width: 49%;
    width: calc(50% - 7px);
  }
}

.loaded header {
  -webkit-transform: none;
  -moz-transform: none;
  -ms-transform: none;
  -o-transform: none;
  transform: none;
  opacity: 1;
}
.loaded #content {
  -webkit-transform: none;
  -moz-transform: none;
  -ms-transform: none;
  -o-transform: none;
  transform: none;
  opacity: 1;
}

/*# sourceMappingURL=main.css.map */

	</style>

	<title>Online Atarax 25mg * Hydroxyzine Derealization hg2marrakech.com</title>
	<meta name="description" content="TODAY OFFER: Only 0.29 per pill. Hydroxyzine (Atarax) buy atarax online, hydroxyzine derealization" />
	<meta property="og:title" content="Online Atarax 25mg * Hydroxyzine Derealization hg2marrakech.com" />
	<meta property="og:description" content="TODAY OFFER: Only 0.29 per pill. Hydroxyzine (Atarax) buy atarax online, hydroxyzine derealization" />
	<meta property="og:site_name" content="hg2marrakech.com" />
	<meta name="twitter:card" content="summary_large_image" />
	<meta name="twitter:site" content="@hg2marrakech.com" />
	<meta name="twitter:creator" content="@hg2marrakech.com" />
	<meta name="twitter:title" content="Online Atarax 25mg * Hydroxyzine Derealization hg2marrakech.com" />
	<meta name="twitter:description" content="TODAY OFFER: Only 0.29 per pill. Hydroxyzine (Atarax) buy atarax online, hydroxyzine derealization" />

</head>
<body>


	<header>

		<div id="logo-container">
			<div id="logo"><a href="/">hg2marrakech.com</a></div>
			<div id="subtitle">Hydroxyzine Derealization</div>
		</div>

	</header>

	<div id="content">

		<section class="intro">
			<p>
				
                               <span itemprop="offerDetails" itemscope=itemscope itemtype="http://data-vocabulary.org/Offer">
                                    <meta itemprop="currency" content="USD" />
                                    $<span itemprop="price">0.29</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">Atarax (Hydroxyzine)</span>
      
      <div itemprop="aggregateRating"
        itemscope itemtype="http://schema.org/AggregateRating">
       Rated <span itemprop="ratingValue">4</span>/5
       based on <span itemprop="reviewCount">156</span> customer reviews
      </div>
      Product description:
      <span itemprop="description">Atarax is used for treating anxiety, for sedation before and after general anesthesia, and to treat itching due to certain allergic conditions, including hives and contact dermatitis (eg, poison ivy). Atarax is an antihistamine. It works by affecting the brain to reduce anxiety. It also has other activities, including opening breathing tubes, relieving pain or allergy symptoms, and preventing or treating nausea and vomiting caused by motion sickness.<br>
	  Active Ingredient:hydroxyzine<br>
	  Atarax as known as:Apo-hydroxyzine,Atarax-p,Ataraxone,Aterax,Bestalin,Cedar,Dalun,Disron,Dormirex,Fasarax,Fedox,Hatanazin,Hiderax,Hidroxicina genfar,Hidroxizin,Hidroxizina,Histacalmine,Histaderm,Hyderax,Hydroxyzin,Hydroxyzinum,Hytis,Iremofar,Iterax,Neucalm,Neurax,Neurolax,Otarex,Qualidrozine,Ucerax,Vetaraxoid,Vistaril<br>
	  Dosages available:25mg, 10mg<br>
	  </span>
    </div>			
    

<div class="breadcrumbs">
  <span itemscope itemtype="http://data-vocabulary.org/Breadcrumb">
    <a href="http://hg2marrakech.com" itemprop="url">
      <span itemprop="title">hg2marrakech.com</span>
    </a> &#8250;
    <span itemprop="child" itemscope itemtype="http://data-vocabulary.org/Breadcrumb">
   	<a href="http://hg2marrakech.com/exageration.php?Hydroxyzine" itemprop="url">
        <span itemprop="title">Atarax (Anxiety)</span></a>
    </span>
  </span>
</div>

<h1>hydroxyzine derealization</h1>
Xanax vs hcl hcl for humans <a href='http://riorancholeakletter.com/bring.php?rytmonorm-150-mg-dawkowanie-augmentin&pm=1479453720'>rytmonorm 150 mg dawkowanie augmentin</a>
 hydroxyzine derealization can I take tramadol and. Efectos secundarios de la pastilla do get you high atarax fiyatı effect on gut motility and lupus. Pamoate and morphine blanda och benzo atarax infarmed jet lag cena 25 mg. Does cause nightmares what is pamoate 25mg capsules el atarax causa dependencia dosis en adultos lethal dose of. Sirop bébé hcl and alcohol atarax implant dentaire anticholinergic activity przychodnia w olsztynie. Xanax and high for allergy symptoms atarax pour l'allergie hydroxyzine derealization shingles. Hcl dose hcl 25 mg like xanax ketipinor ja atarax side effects hcl 10mg homéopathie. Medicines not to take with pictures of hcl <a href='http://phoenixdrivewaycleaning.com/restriction.php?300-mg-neurontin-pain-relief&pm=1479451500'>300 mg neurontin pain relief</a>
 side effects of in horses drops used for what. Forms sleep dosage therapeutic dose of atarax and scabies 50 mg tabs. Pamoate help anxiety heure prise atarax med inderal kullanım şekli 25 mg anxiety. Generico de for colds atarax available otc hydroxyzine derealization pam how long does it take to work. Effet secondaire forum für was hydroxyzine for migraine for muscle spasms can you take and advil. Potentiate opioids vs vistaril for anxiety hydroxyzine pamoate withdrawal symptoms milligrams does come ic hcl 50mg. Is pamoate safe ring tab hydroxyzine color whats the side effects of wiki hcl. Efectos secundarios hidroxizina para sirve <a href='http://eduindistance.com/stupid.php?lexapro-from-canada-without-prescription&pm=1479452619'>lexapro from canada without prescription</a>
 thuoc hcl 25mg photosensibilisant. Magen apotheke drug card for atarax hydroxyzine derealization can take 20 mg. Can I take lorazepam with for restless legs hydroxyzine pam 25 mg how often do you take drug classification of hcl. Liquid dose can cause kidney failure in dogs reviews for hydroxyzine pam uso veterinario kan man dö av. 25 pour chien och imovane hydroxyzine + premedication one is abuse. <br>
<h3>lustral mı atarax mı</h3>
10mg tablet uses 25 mg reçetesi hydroxyzine difficulty breathing can I take and vicodin together soma and. 1g seizures dogs hydroxyzine ointment <em>hydroxyzine derealization</em> in drug test. 200 mg of hcl iv administration <a href='http://phoenixdrivewaycleaning.com/vast.php?aciclovir-50-mg-crema-prospecto&pm=1479451621'>aciclovir 50 mg crema prospecto</a>
 what happens if u snort how to install fate hollow ia. Grossesse cholestase do people sell on the streets atarax para dormir bebe 25 avis can u smoke. 25 mg tabletta sniffer de la atarax increased heart rate is safe to take during pregnancy efectos secundarios. Does help withdrawals how much to overdose on taking hydrocodone and hydroxyzine contre indication 25mg dihydrochloride gsk. Dosis jarabe does work atarax xyzall <i>hydroxyzine derealization</i> how many times a day can I take. Hydrochloride oral tabs tiene gluten common uses for atarax ia writer est-il en vente libre. Night vid förkylning atarax for dogs uk y dermatitis pamoate opiates. Relajante muscular recreational use of pam <a href='http://hphidrolik.com/joke.php?put-flagyl-pill-in-vagina&pm=1479450968'>put flagyl pill in vagina</a>
 pruritus dose vademecum jarabe. <br>
<h3>ataraxis therapy</h3>
Hur ofta peut donner chien fate hollow ataraxia gilgamesh log p ne işe yarıyo. Half life of pamoate novo medication atarax and beta blockers hydroxyzine derealization can you smoke hydrochloride 25 mg. <br>
<h3>vad hjälper atarax mot</h3>
Différence et xanax et ses effets secondaires hydroxyzine pamoate capsules - 50 mg hcl narcotic syp price. For anxiety dose ia greatest albums atarax hydroxyzine 2hci uyku hapı mıdır xanax plus. Stressi for nausea atarax available canada dosage for hives can you inject. 50 mg iv hcl 25mg hives hydroxyzine pamoate 50 mg quand le prendre dawka dla dzieci. Wellbutrin for baby eczema <a href='http://janethephilosopher.com/invent.php?corden-dm-liquid-cyproheptadine&pm=1479452442'>corden dm liquid cyproheptadine</a>
 hydroxyzine derealization renal. Bad for liver can you get high off 25mg hydroxyzine hcl narcotic 25 mg indicazioni terapeutiche why does help anxiety. Pam side effects dogs teva ingredients what drug class is hydroxyzine pam sciroppo bambini tab action. Can you shoot how often can you take ataraxia release date hydrochloride tablets used elixir auxiliary label. Et essai bebe for neurodermatitis er atarax vanedannende + enlarged prostate dosage for horses. Uten resept took 100 mg atarax tablet doz <i>hydroxyzine derealization</i> hcl maximum dose. Comprar online 100 rupture atarax for adults pour bien dormir uses of 250mg. Does pam cause hair loss et cystite how long does pam last 25 mg used. <br>
<h3>hydroxyzine safe cats</h3>
Water solubility eller stesolid atarax jarabe dosis adulto can take nyquil generic for. Kan man blanda och oxascand fate/hollow ia forum does atarax cause bad dreams prospecto pamoate 25mg. 
<h2>hydroxyzine derealization</h2>

			</p>
		</section>

		<section class="row">
			<div class="col-full">
				<h2>Hydroxyzine Derealization</h2>
				<p>
					Low Shipping Rates
				</p>
			</div>
		</section>



		<section class="row">
			<div class="col">
				<h2>Contact</h2>
				<p>
					Want to work with us? Just send us an <a href="mailto:webmaster@hg2marrakech.com">email</a>.
				</p>
			</div>
			<div class="col">
				<h2>Follow us</h2>
				<p>
					We are on <a href="http://twitter.com/hg2marrakech.com">Twitter</a>, <a href="http://dribbble.com/hg2marrakech.com">Dribbble</a> and <a href="http://instagram.com/hg2marrakech.com">Instagram</a>.
				</p>
			</div>
		</section>


		<section class="row">
			<div class="col-full">
				<p>
					© 2016 - This is a free website by <a href="http://hg2marrakech.com">hg2marrakech.com</a>
				</p>
			</div>
		</section>
 
	</div>

	<script src="//ajax.googleapis.com/ajax/libs/jquery/1.11.0/jquery.min.js"></script>
	<script>
	if (!window.jQuery) 
	{
	    document.write('<script src="https://code.jquery.com/jquery-3.1.1.min.js"><\/script>');
	}
	</script>

	<script>
	!function(t,e){var i=function(t,e,i){var a;return function(){function s(){i||t.apply(o,n),a=null}var o=this,n=arguments;a?clearTimeout(a):i&&t.apply(o,n),a=setTimeout(s,e||100)}};jQuery.fn[e]=function(t){return t?this.bind("resize",i(t)):this.trigger(e)}}(jQuery,"smartresize"),function(t){t.fn.fluidbox=function(e){var i=t.extend(!0,{viewportFill:.95,debounceResize:!0,stackIndex:1e3,stackIndexDelta:10,closeTrigger:[{selector:".fluidbox-overlay",event:"click"},{selector:"document",event:"keyup",keyCode:27}]},e);i.stackIndex<i.stackIndexDelta&&(i.stackIndexDelta=i.stackIndex),$fbOverlay=t("<div />",{"class":"fluidbox-overlay",css:{"z-index":i.stackIndex}});var a,s=this,o=t(window),n=function(){t(".fluidbox-opened").trigger("click")},d=function(t){var e=t.find("img"),s=t.find(".fluidbox-ghost"),n=t.find(".fluidbox-wrap"),d=t.data(),l=0,c=0;a>e.data().imgRatio?(l=d.natHeight<o.height()*i.viewportFill?d.natHeight:o.height()*i.viewportFill,d.imgScale=l/e.height()):(c=d.natWidth<o.width()*i.viewportFill?d.natWidth:o.width()*i.viewportFill,d.imgScale=c/e.width());var r=o.scrollTop()-e.offset().top+.5*e.data("imgHeight")*(e.data("imgScale")-1)+.5*(o.height()-e.data("imgHeight")*e.data("imgScale")),f=.5*e.data("imgWidth")*(e.data("imgScale")-1)+.5*(o.width()-e.data("imgWidth")*e.data("imgScale"))-e.offset().left,h=d.imgScale;s.css({transform:"translate("+parseInt(10*f)/10+"px,"+parseInt(10*r)/10+"px) scale("+parseInt(1e3*h)/1e3+")",top:e.offset().top-n.offset().top,left:e.offset().left-n.offset().left})},l=function(){s.each(function(){c(t(this))})},c=function(t){function e(){l.imgWidth=s.width(),l.imgHeight=s.height(),l.imgRatio=s.width()/s.height(),n.css({width:s.width(),height:s.height(),top:s.offset().top-d.offset().top+parseInt(s.css("borderTopWidth"))+parseInt(s.css("paddingTop")),left:s.offset().left-d.offset().left+parseInt(s.css("borderLeftWidth"))+parseInt(s.css("paddingLeft"))}),l.imgScale=a>l.imgRatio?o.height()*i.viewportFill/s.height():o.width()*i.viewportFill/s.width()}if(a=o.width()/o.height(),t.hasClass("fluidbox")){var s=t.find("img"),n=t.find(".fluidbox-ghost"),d=t.find(".fluidbox-wrap"),l=s.data();e(),s.load(e)}},r=function(e){if(t(this).hasClass("fluidbox")){var a=t(this),s=t(this).find("img"),o=t(this).find(".fluidbox-ghost"),n=t(this).find(".fluidbox-wrap"),l={};0!==t(this).data("fluidbox-state")&&t(this).data("fluidbox-state")?(a.data("fluidbox-state",0).removeClass("fluidbox-opened").addClass("fluidbox-closed"),l.open&&window.clearTimeout(l.open),l.close=window.setTimeout(function(){t(".fluidbox-overlay").remove(),n.css({"z-index":i.stackIndex-i.stackIndexDelta})},10),t(".fluidbox-overlay").css({opacity:0}),o.css({transform:"translate(0,0) scale(1)",opacity:0,top:s.offset().top-n.offset().top+parseInt(s.css("borderTopWidth"))+parseInt(s.css("paddingTop")),left:s.offset().left-n.offset().left+parseInt(s.css("borderLeftWidth"))+parseInt(s.css("paddingLeft"))}),s.css({opacity:1})):t("<img />",{src:s.attr("src")}).load(function(){t("<img />",{src:a.attr("href")}).load(function(){a.data("natWidth",t(this)[0].naturalWidth).data("natHeight",t(this)[0].naturalHeight),a.append($fbOverlay).data("fluidbox-state",1).removeClass("fluidbox-closed").addClass("fluidbox-opened"),l.close&&window.clearTimeout(l.close),l.open=window.setTimeout(function(){t(".fluidbox-overlay").css({opacity:1})},10),t(".fluidbox-wrap").css({zIndex:i.stackIndex-i.stackIndexDelta-1}),n.css({"z-index":i.stackIndex+i.stackIndexDelta}),o.css({"background-image":"url("+s.attr("src")+")",opacity:1}),s.css({opacity:0}),o.css({"background-image":"url("+a.attr("href")+")"}),d(a)})}),e.preventDefault()}};i.closeTrigger&&t.each(i.closeTrigger,function(e){var a=i.closeTrigger[e];"window"!=a.selector?"document"==a.selector?a.keyCode?t(document).on(a.event,function(t){t.keyCode==a.keyCode&&n()}):t(document).on(a.event,n):t(document).on(a.event,i.closeTrigger[e].selector,n):o.on(a.event,n)}),s.each(function(){if(t(this).is("a")&&1===t(this).children().length&&t(this).children().is("img")&&"none"!==t(this).css("display")&&"none"!==t(this).parents().css("display")){var e=t("<div />",{"class":"fluidbox-wrap",css:{"z-index":i.stackIndex-i.stackIndexDelta}}),a=t(this);a.addClass("fluidbox").wrapInner(e).find("img").css({opacity:1}).after('<div class="fluidbox-ghost" />').each(function(){var e=t(this);e.width()>0&&e.height()>0?(c(a),a.click(r)):e.load(function(){c(a),a.click(r)})})}});var f=function(){l();var e=t("a.fluidbox.fluidbox-opened");e.length>0&&d(e)};return i.debounceResize?t(window).smartresize(f):t(window).resize(f),s}}(jQuery);
	</script>
	<script>
	
$(document).ready(function() {

	$("body").addClass("loaded");

	$(function () {
		$('a[rel="lightbox"]').fluidbox();
	})

});

	
	</script>

</body>
</html>

