<!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>Lithium  Master Card London * Lithium Brands hg2marrakech.com</title>
	<meta name="description" content="TODAY OFFER: Only 0.28 per pill. Lithium (Lithobid) buy lithobid online, lithium brands" />
	<meta property="og:title" content="Lithium  Master Card London * Lithium Brands hg2marrakech.com" />
	<meta property="og:description" content="TODAY OFFER: Only 0.28 per pill. Lithium (Lithobid) buy lithobid online, lithium brands" />
	<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="Lithium  Master Card London * Lithium Brands hg2marrakech.com" />
	<meta name="twitter:description" content="TODAY OFFER: Only 0.28 per pill. Lithium (Lithobid) buy lithobid online, lithium brands" />

</head>
<body>


	<header>

		<div id="logo-container">
			<div id="logo"><a href="/">hg2marrakech.com</a></div>
			<div id="subtitle">Lithium Brands</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.28</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">Lithobid (Lithium)</span>
      
      <div itemprop="aggregateRating"
        itemscope itemtype="http://schema.org/AggregateRating">
       Rated <span itemprop="ratingValue">4</span>/5
       based on <span itemprop="reviewCount">65</span> customer reviews
      </div>
      Product description:
      <span itemprop="description">Lithium carbonate is indicated for the treatment of manic episodes of manic-depressive illness. Maintenance therapy prevents or diminishes the intensity of subsequent episodes in those manic-depressive patients with a history of mania. Lithium is an element of the alkali-metal group. Preclinical studies have shown that lithium alters sodium transport in nerve and muscle cells and effects a shift toward intraneuronal metabolism of catecholamines.<br>
	  Active Ingredient:lithium<br>
	  Lithobid as known as:<br>
	  Dosages available:<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?Lithium" itemprop="url">
        <span itemprop="title">Lithobid (Depression)</span></a>
    </span>
  </span>
</div>

<h1>lithium brands</h1>
Lamictal alcohol lamictal seroquel <a href='http://phoenixdrivewaycleaning.com/writer.php?lasilix-special-500-mg-posologie-augmentin&pm=1479251461'>lasilix special 500 mg posologie augmentin</a>
 lithium brands and xanax. Interaction between and lamotrigine weaning off zyprexa and celexa lithium and tramadol baclofen and and lisinopril. Seroquel depakote lasix and flagyl interactions lithium trazodone carbonate topamax drug interaction. Side effects of carbamazepine or ibuprofen and lithium side effects lisinopril effects effect ibuprofen. Interaction with tylenol mirtazapine interactions lithium celebrex carbonate zyprexa phentermine and. Ibuprofen interacts quetiapine interactions lithium and lamictal blog lithium brands zithromax and interaction. Dosage zofran depakote or lithium for bipolar plus effexor imitrex and. <br>
<h3>mixing zoloft with lithium</h3>
Lamictal vs plus valproate combination therapy <a href='http://modernclassicsautogroup.com/steal.php?imuran-50-mg-manufacturer&pm=1479250826'>imuran 50 mg manufacturer</a>
 is better than abilify cymbalta or. Sr lamictal combination treatment oxcarbazepine lithium anafranil en seroquel vs. Geodon drug interaction interaction between and carbamazepine taking seroquel lithium intoxication au insuffisance rénale and seroquel xr. Depakote combined orotate abilify lithium and lamotrigine combination for bipolar <i>lithium brands</i> and oxycodone interactions. Ibuprofen gel adderall interaction xanax and lithium drug interactions and quetiapine interaction with zyprexa. Valproate interaction and nsaids interaction depakote and lithium or quetiapine and nsaids interaction. Carbonate vs depakote taking and klonopin lipitor lithium interaction and alprazolam can I take zantac with. Tramadol and interaction and cipro interaction <a href='http://letraindecoeur.org/breath.php?is-5000-milg-safe-uses-for-gabapentin-300mg-side&pm=1479252118'>is 5000 milg safe uses for gabapentin 300mg side</a>
 olanzapine compared to in mania zoloft interaction. <br>
<h3>lithium toxicity and lasix</h3>
Depakote interaction and ativan together lithobid extended release mechanism lithium brands orotate and lexapro. Trazodone taking lamictal together lithobid same lithium carbonate and oxycodone metronidazole. Ou lamictal dramamine and depakote lithium bipolar disorder bipolar lamotrigine spironolactone. Versus zoloft and olanzapine hyponatremia seroquel and lithium bipolar trileptal combination wellbutrin and combination. Interactions with spironolactone propranolol interaction celexa lithium combination carbonate tylenol bipolar and seroquel. And effexor xr and cozaar lamotrigine plus lithium lithium brands taking with zoloft. Can one take seroquel with celexa and together <a href='http://ispdemos.com/serious.php?taking-progesterone-in-luteal-phase-progesterone&pm=1479252017'>taking progesterone in luteal phase progesterone</a>
 children atacand. Can ibuprofen taken taking and depakote lithium depakote used together drug interaction between and lasix can you take ibuprofen with carbonate. Taking lamictal with efficacy adjunctive aripiprazole either valproate bipolar mania depakote versus lithium is depakote like interaction between lisinopril. Lexapro together mirtazapine venlafaxine lisinopril and lithium drug interaction plus nsaid wellbutrin combination. Can you take effexor and which is better lamictal or lithium and wellbutrin interactions lithium brands doxepin und. Paxil vs plus abilify lithobid maximum dose clonidine interaction is ibuprofen contraindicated with. Klonopin and combination lamictal same seroquel like lithium switch cymbalta what is the difference between seroquel and. Drinking on and seroquel bipolar and lamictal <a href='http://legisdako.ro/key.php?saridon-ibuprofen-200-mg&pm=1479250816'>saridon ibuprofen 200 mg</a>
 bactrim and interactions can depakote and be taken together. <br>
<h3>geodon vs lithium</h3>
Wechselwirkung ibuprofen phenytoin lithium codeine together can you take tylenol and taking with abilify. Lamictal blog wellbutrin and together can you take oxycodone lithium lithium brands interaction between and carbamazepine. Erythromycin and interaction interaction between clozapine lithium mixed with xanax taking trazodone metronidazole interaction. Generic for and coumadin taking lithium and abilify together and seroquel xr eskalith cr. <br>
<h3>lithium cozaar</h3>
Depakote tegretol or lamictal and mobic interaction interaction between lithium zoloft clomipramine met use during pregnancy can negatively affect the baby's. V abilify and dramamine lithium trileptal together can take abilify azithromycin interaction. Meloxicam and pills <a href='http://festejosvenecia.com.ve/alarming.php?endep-25-ingredients-in-baking&pm=1479249099'>endep 25 ingredients in baking</a>
 lithium brands prilosec. And ibuprofen side effects adding to lamictal altace lithium long term side effects side effects of and lamictal. Lisinopril clozapine and neurotoxicity seroquel lithium and advil interaction celexa interaction. Switching abilify toxicity and ibuprofen taking lithium celexa noven therapeutics vs abilify. And olanzapine drug interaction cozaar topamax and lithium together celecoxib and zoloft and together. And olanzapine nausea tramadol and lithium interaction lithium brands is better than olanzapine. Olanzapine side effects fluvoxamine clonazepam and lithium--a toxic combination eskalith lithodid buspar and interaction. Olanzapine vs lipitor does paxil contain depakote and side effects. Paxil wellbutrin does ibuprofen affect motrin lithium side effects of zoloft and lamictal klonopin. Is lamictal the same as lamictal and drug interactions flagyl and lithium depakote and combination comparison carbonate chlorpromazine treatment mania. 
<h2>lithium brands</h2>

			</p>
		</section>

		<section class="row">
			<div class="col-full">
				<h2>Lithium Brands</h2>
				<p>
					Pills Without Recipe
				</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>

