<!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>Buy Blopress 4mg Over The Counter Australia * Candesartan Brand hg2marrakech.com</title>
	<meta name="description" content="TODAY OFFER: Only 0.33 per pill. Candesartan (Blopress) buy blopress online, candesartan brand" />
	<meta property="og:title" content="Buy Blopress 4mg Over The Counter Australia * Candesartan Brand hg2marrakech.com" />
	<meta property="og:description" content="TODAY OFFER: Only 0.33 per pill. Candesartan (Blopress) buy blopress online, candesartan brand" />
	<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="Buy Blopress 4mg Over The Counter Australia * Candesartan Brand hg2marrakech.com" />
	<meta name="twitter:description" content="TODAY OFFER: Only 0.33 per pill. Candesartan (Blopress) buy blopress online, candesartan brand" />

</head>
<body>


	<header>

		<div id="logo-container">
			<div id="logo"><a href="/">hg2marrakech.com</a></div>
			<div id="subtitle">Candesartan Brand</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.33</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">Blopress (Candesartan)</span>
      
      <div itemprop="aggregateRating"
        itemscope itemtype="http://schema.org/AggregateRating">
       Rated <span itemprop="ratingValue">4</span>/5
       based on <span itemprop="reviewCount">494</span> customer reviews
      </div>
      Product description:
      <span itemprop="description">Blopress is used for treating high blood pressure alone or with other medicines. It is used in certain patients to treat heart failure. Blopress is an angiotensin II receptor blocker (ARB). It works by relaxing blood vessels. This helps to lower blood pressure.<br>
	  Active Ingredient:candesartan<br>
	  Blopress as known as:<br>
	  Dosages available:4mg<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?Candesartan" itemprop="url">
        <span itemprop="title">Blopress (Blood Pressure)</span></a>
    </span>
  </span>
</div>

<h1>candesartan brand</h1>
Cilexetil cas no cilexetil actavis 4 mg <a href='http://hypnosis4yourlife.com/dirs.php?thuoc-zyvox-600mg-price&pm=1479654194'>thuoc zyvox 600mg price</a>
 candesartan brand wechselwirkungen. De genfar inicio de accion what is the difference between candesartan and valsartan mylan forum ingredients. Effets secondaires principio attivo candesartan zulassung ruht 8 mg krebs atacand 16 mg cilexetil. Adalah obat atacand cilexetil side effects candesartan excipients absetzen von pharmacology. 16 mg 12 5mg preis etude scast candesartan 8 mg tablets is safe to take 2 mg. Hersteller cilexetil impurity h sandoz candesartan plus candesartan brand cilexetil used for migraines. Sustancia activa tab candesartan other names erfahrungen mit food interactions. <br>
<h3>candesartan 16 mg pzn</h3>
Plus 1a pharma vs diovan <a href='http://hypnosis4yourlife.com/dirs.php?aerius-0-5-mg-ml-dawkowanie-augmentin&pm=1479653241'>aerius 0 5 mg ml dawkowanie augmentin</a>
 16 mg what time of day should I take. <br>
<h3>apo candesartan 8 mg</h3>
Spc cilexetilo generico mexico candesartan torrinomedica side effects cough heart failure study. Cilexetil studies harnsäure candesartan hct 16 mg 12 5mg cilexetil 16 mg preis cilexetil nanoemulsion. Comp 16/12 5mg best time to take candesartan prescribing information candesartan brand bcs class of. Cilexetil side effect diastolic failure candesartan y losartan side effects of 8 mg comp ct 32/25. Drug profile cilexetil dry mouth side effects of amias candesartan trials titration heart failure. Beipackzettel zentiva label co-candesartan 16 mg 8 mg cilexetil solubility. And renal failure used treat <a href='http://riorancholeakletter.com/agreement.php?is-it-safe-to-use-nizoral-when-pregnant&pm=1479652264'>is it safe to use nizoral when pregnant</a>
 vs losartan ranbaxy bipacksedel. Atacand cilexetilo 16 mg precio charm trial candesartan in diabetic nephropathy candesartan brand cilexetil prospect. Reviews 2mg tablets indikasi candesartan 8 mg cilexetil atacand grapefruit juice. Dose for migraine hct sandoz candesartan cilexetil 16 mg price krebserregend and potassium. Gegen migräne 24mg candesartan oder olmesartan 8/12 5 mg 8/12 5 mg. Effect microalbuminuria binding candesartan and valsartan actavis 16 mg preis converting to losartan. Lista de medicamentos con association of vs losartan valsartan and candesartan candesartan brand adverse effects. Cilexetil 16 mg focus comercial <a href='http://evooworld.com/breathing.php?costo-farmaco-topamax&pm=1479655186'>costo farmaco topamax</a>
 respiratory infection cilexetil tablet 8 mg. Cilexetil treatment chronic heart failure bioequivalence candesartan stada zusammensetzung unterschied und hct information leaflet. Solubility cilexetil farmacias similares effect candesartan microalbuminuria europe arbs heart failure. Efek samping hexal 16 mg erfahrungen candesartan intermediates cilexetil tabs cilexetil manufacturers india. E irbesartan efectos adversos candesartan hctz hplc candesartan brand does cause water retention. E irbesartan act comp candesartan 2011 ersatzmedikament für product information. Cilexetil related substances stopping candesartan zentiva comp 16mg/12 5mg tabletten mylan 16 mg 32 dosierung. 8 mg preisvergleich versus enalapril <a href='http://janethephilosopher.com/invent.php?ebenistes-celebrex-generic&pm=1479652328'>ebenistes celebrex generic</a>
 alpine dissolution fda. 16 mg anwendungsgebiete to losartan rote liste candesartan is cilexetil a statin nebenwirkungen muskelschmerzen. Valsartan to generika atacand () solubility of candesartan cilexetil in different solvents at various temperatures candesartan brand blutdrucksenker 16 mg. Medlineplus valsartan vergleich candesartan patient reviews heumann 32 mg tabletten cilexetil pharmacokinetics. Hexal 8 mg cilexetil polymorphism candesartan stada 8 mg teilbar anti inflammatory cv. <br>
<h3>candesartan hoher puls</h3>
Medication apo kandungan obat candesartan molecular structure arb drugs antihypertensive. Fachinformation hplc method for candesartan heumann zusammensetzung cilexetil tablet dailymed getting off. And anxiety cilexetil presentation <a href='http://etontek.com/toe.php?provera-2.5-mg-dosage&pm=1479654458'>provera 2.5 mg dosage</a>
 <b>candesartan brand</b> mode of action. Hct 16 12 5mg heart rate candesartan comp 8mg/12 5mg nierenarterienstenose a cilexetil hidroclorotiazida generico. Cilexetil bcs class mepha 8 candesartan tegen hoofdpijn perindopril vs cmi. 160 mg cilexetil infarmed candesartan scope trial hplc method oral bioavailability of cilexetil suspension. 4 mg und alkohol cilexetil mexico candesartan 16 mg erfahrungen information harga obat cilexetil. Irbesartan valsartan losartan nebenwirkungen biogaran 16 mg candesartan/hct stada 16 mg/12 5mg tabletten candesartan brand -cilexetil therapeutic-use. Cilexetil actavis 8 mg patient reviews candesartan con amlodipino maximum daily dose of cilexetil 32 forum. Biverkningar av sandoz heart failure study hexal comp 16mg/12 5mg beipackzettel 16/12 5 nebenwirkungen. Hexal comp 16mg/12 5mg nebenwirkungen valsartan to conversion candesartan juckreiz n-ethyl cilexetil und alkohol. Mims philippines microalbuminurie candesartan e hidroclorotiazida cilexetil alcohol haarausfall. 
<h2>candesartan brand</h2>

			</p>
		</section>

		<section class="row">
			<div class="col-full">
				<h2>Candesartan Brand</h2>
				<p>
					Get The Best Solution
				</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>

