a:6:{i:0;s:16913:"				<div class="h1"><h1>Ladakh Fixed Departure Package</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.anmolparyatan.co.in/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.anmolparyatan.co.in/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Ladakh Fixed Departure Package</p>
				<br />
				
								
						<script language="javascript"> 
							function topDestinationToggle(showHideDiv, switchTextDiv) {
							var ele = document.getElementById(showHideDiv);
							var text = document.getElementById(switchTextDiv);
							if(ele.style.display == "block") {
								ele.style.display = "none";
							  text.innerHTML = "View More &#9660;";
							}
							else {
							  ele.style.display = "block";
							  text.innerHTML = "View Less &#9650;";
							}
							}
		                </script>
											<script type="text/javascript">			
					(function($){	
					  $(function(){
						$('[id^=detailslider]').each(function(){
							$(this).DG_Slider({
								auto: true, mode:'fade', pager:true, pagerType:'short',controls:true
							});
						})
				
						$('a[rel=gall]').fancybox()
					  });	
					}(jQuery))
					</script>
					
					<br />
					<div class="data">
					<table class="w100 formTable bdr0 imgWidth">
					<tr>
					<td class="p10px">
					<table class="w100 packageForm">
											<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						6 Nights / 7 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Leh Ladakh</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 34000 Per Person						</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.anmolparyatan.co.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Ladakh Fixed Departure Package - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>
						<a href="#" onclick="document.getElementById('frmpackagedetail').submit();" class="button p7px pl12px pr12px c5px b large dib mt10px">Book Your Tour</a>
						<input type="hidden" name="pkg_slno" value="137954"/>
						</form>
						</p>
						</td>
						</tr>
											</table>
					</td>
											<td class="p10px vat imgWidth150 w150px lh0">
						<div class="demo-wrap">
						<ul class="lsn m0px p0px" >
															<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_12/332639/217577.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_12/332639/217577.jpg"  height="150"  width="150"    alt="Ladakh Fixed Departure Package" title="Ladakh Fixed Departure Package" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Meals other than those specified above<br />
Personal expenses like portages, tips, laundry, mineral water etc.<br />
Monument entrances, camera charges, etc.<br />
Any activity not mentioned in the inclusions<br />
Travel Insurance<br />
Additional cost due to flight cancellation/ roadblocks, Political unrest etc.<br />
Additional cost of Hotel to be borne by customer in case of road blockage due to snow. (Enroute Nubra & Pangong)<br />						<div class="headHr">
			            <p class="p7px b pl10px xlarge">Tour Itinerary</p>
			            </div>
			            
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 1:</b> Arrive In Leh
								</p>
								<p class="aj">Upon arrival in Leh, welcome by our local representative and transfer to a Ladakhi<br />
Style Hotel. Later take a complete rest for Acclimatization to the arid high altitude of Leh (3505 m). Later in the evening enjoy the sunset point (Shanti stupa & Leh Market) followed by dinner and overnight stay at the Hotel.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 2:</b> Sham Valley Excursion (90 Kms Round Trip)
								</p>
								<p class="aj">After breakfast you drive downstream along the River Indus on Leh – Kargil Highway. Enjoy sightseeing with Hall of Fame (Museum Constructed by India Army) near Leh is worth a visit for every Indian, and proceed further to Gurudwara Patthar Sahib Nestled deep in the Himalayas, A drive of another 4 km took us to Magnetic Hill which defies the law of gravity & further Driving through a picturesque landscape we reached the Confluence Of The Indus And Zanskar River. After visiting above places we drive back to Leh enroute visiting Spituk Monastery, Built in 15th century during the reign of Grags ‘bum-lde, these new Gelug-pa monastery was built like fortress on the summit of crags. Evening at leisure and Overnight at Hotel in Leh</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 3:</b> Leh - Nubra Valley (125 Kms / 4Hrs)
								</p>
								<p class="aj">Today after breakfast drive about 04- 05 hrs. [125 kms] to Nubra – known as valley of flowers. After drive about 02 hrs. we will reach – The world's highest motorable road called Khardungla high about 18,380 feet above sea level. From the top we can see the most beautiful view of Indus valley & its snow covered peaks towering the sky and other side of the pass if weather remain clear we can see Karakorum mountain range and peaks too. We descend down to beautiful valley & transfer to the hotel, later have rest till evening ,before sunset we will take you for a short drive to Hunder sand dunes to visit & ride double humped bactrian camel, later back to hotel for overnight stay. If time permits we will have a village walk to see local people & its culture.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 4:</b> Nubra To Leh
								</p>
								<p class="aj">Morning after breakfast we will visit the most picturesque Disket monastery on the hill top. Later continue drive to other side of Nubra valley – was the main part of silk route. We will continue our drive <br />
back to Leh via Khardungla. Reach Leh & transfer to Hotel for overnight stay.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 5:</b> Leh To Pangong, Via Changla Pass - 5320 mts) (150 kms /5-6hrs)
								</p>
								<p class="aj">After breakfast, drive (154 km/ 6 hrs) to the spectacular Changthang Valley, winding your way over the exhilarating Chang la (5320m.)- The second highest point of our journey. The landscape on the way to Pangong is just spectacular. Overnight in camp or guesthouse.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 6:</b> Pangong Explore And Drive Back To Leh
								</p>
								<p class="aj">The Lake is situated at 13,930 ft./ about 4300 mts. above sea level and is 125 km long, but is only four km at its widest, and extends almost in a straight line, way to Tibet; in fact, only a quarter of the lake is in India. En route you will see some Himalayan marmots & migrated birds. Later leave for Leh for overnight in a hotel</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 7:</b> Departure
								</p>
								<p class="aj">Transfer to Airport for onwards journey.</p>
								</td>
								</tr>
								</table>					
								</div>						<br />
												 <p class="headHr p7px b pl10px xlarge">Tour Detail</p>
			             <div class="data p15px aj">
										
						<p class="large b mb5px dif">Inclusions :</p>
						<ul>
															<li>Hotel</li>
																		<li>Meals</li>
																		<li>Sightseeing</li>
																<li>Return Airfare from New Delhi/Mumbai</li><li>
Accommodation on twin sharing basis.</li><li>
Meals: Breakfast & Dinner.</li><li>
Assistance upon arrival and departure, welcome in Ladakhi style tea In Hotel or Guest House.</li><li>
Transfers, Sightseeing & overland journey by non air-conditioned Vehicle (Upto 6 Pax Qualis/Xylo/Innova & Upto 12 Pax Tempo Traveler on sharing basis).</li><li>
Wildlife fee.</li><li>
Environment fee charges.</li><li>
First Aid Medical kit in Cab.</li>
													</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Meals other than those specified above</li><li>
Personal expenses like portages, tips, laundry, mineral water etc.</li><li>
Monument entrances, camera charges, etc.</li><li>
Any activity not mentioned in the inclusions</li><li>
Travel Insurance</li><li>
Additional cost due to flight cancellation/ roadblocks, Political unrest etc.</li><li>
Additional cost of Hotel to be borne by customer in case of road blockage due to snow. (Enroute Nubra & Pangong)</li></ul><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p><p style="font-style: normal; page-break-inside: avoid"><font color="#000000"><font face="Calibri"><font size="2" style="font-size: 11pt"><u><b><span style="background: transparent">Payment Policy:</span></b></u></font></font></font>

<p style="page-break-inside: avoid; text-decoration: none"><font color="#000000"><span style="background: transparent"><font face="Calibri"><font size="2" style="font-size: 11pt"><span style="font-style: normal"><span style="font-weight: normal">25% of Package cost at the time of confirmation</span></span></font></font></span></font>

<p style="page-break-inside: avoid; text-decoration: none"><font color="#000000"><span style="background: transparent">&nbsp;<font face="Calibri"><font size="2" style="font-size: 11pt"><span style="font-style: normal"><span style="font-weight: normal">Within 30 days 100% of total cost</span></span></font></font></span></font>~^#^~~^#^~<ul>
	<li>Per person prices are quoted on twin-share basis (2 persons sharing a room).</li>
	<li>A maximum of 3 adults are allowed in one room.</li>
	<li>The third occupant of the room shall be provided a mattress/rollaway bed.</li>
	<li>The package price does not include &ndash;Expenses of personal nature, such as laundry, telephone calls, room service, alcoholic beverages, mini bar charges, tips, portage, camera fees etc. Any meals and services not specifically mentioned in the inclusions</li>
	<li>Airline seats and hotel rooms are subject to availability at the time of booking.</li>
	<li>In case of unavailability in the listed hotels, arrangement for an alternate accommodation will be made in a hotel of similar standard.</li>
	<li>Room heaters if required can be provided on chargeable basis, subject to availability.</li>
	<li>Hot water is only provided for 2 hours during the morning and evening in Leh. In camps, hot water is only available for a limited time in the morning.</li>
	<li>Only vegetarian meals are served at Nubra and Pangong.</li>
	<li>Connectivity (phone as well as internet) is poor and unreliable in Ladakh. Most hotels will not have a Wi-Fi connection.</li>
	<li>Transportation shall be provided as per the itinerary and will not be at disposal.</li>
	<li>OYO reserves the right to modify the itinerary at any point, due to reasons including but not limited to: Force Majeure events, strikes, fairs, festivals, weather conditions, traffic problems, overbooking of hotels / flights, cancellation / re-routing of flights, closure of / entry restrictions at a place of visit, etc. While we will do our best to make suitable alternate arrangements, we would not be held liable for any refunds/compensation claims arising out of this.</li>
	<li>It is mandatory for all guests to carry valid photo IDs (Passport/Driving License/Voter ID Card). PAN Card is not accepted at many places as a valid photo ID.</li>
	<li>People from Pakistan, Sri Lanka, Bangladesh, China, Myanmar and Bhutan cannot travel to restricted areas outside Leh such as Nubra Valley, Pangong, and Tsomoriri etc. Nationals of countries other than these can travel to Ladakh provided they don&rsquo;t have a Diplomatic passport.</li>
	<li>For queries regarding cancellations and refunds, please refer to our Cancellation Policy.</li>
	<li>Disputes, if any, shall be subject to the exclusive jurisdiction of the courts in New Delhi.</li>
</ul>						
    	<p class="h dif xlarge b mb5px">HOTEL DETAILS:</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="data p5px">Destinations</td>
				<td class="data p5px">Standard</td>
				<td class="data p5px">Deluxe</td>
			</tr>
			<tr>
				<td class="data p5px">Leh</td>
				<td class="data p5px">Dimbir Residency/ Royal Hills /similar</td>
				<td class="data p5px">City palace / Grand Willow /similar</td>
			</tr>
			<tr>
				<td class="data p5px">Nubra</td>
				<td class="data p5px">Nubra Eco Village/Paradise Camp / Similar</td>
				<td class="data p5px">Nubra Eco Village (Super Deluxe)/ Boutique Camp /similar</td>
			</tr>
			<tr>
				<td class="data p5px">Pangong</td>
				<td class="data p5px">Nomad/ Pangong holiday cottage /Similar</td>
				<td class="data p5px">Pangong resort /Marsimik camp/ Similar</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">PRICING</p>
    	<div class="otherDetails aj">● The above mentioned Prices are subject to availability & Vehicle will be provided on Sharing basis<br>
● The above mentioned prices are Per person on twin sharing basis<br>
● Above prices are inclusive of Service Tax & OYO Take Rate<br>
Private INNOVA Supplement Cost : 18500/- <br>
Date Change Penalty: 1500 Per Person over n above current selling Price</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="data p5px">EX- DELHI</td>
				<td class="data p5px">Category</td>
				<td class="data p5px">Tempo Traveller</td>
			</tr>
			<tr>
				<td class="data p5px">AUGUST</td>
				<td class="data p5px">STA</td>
				<td class="data p5px">30999</td>
			</tr>
			<tr>
				<td class="data p5px"> </td>
				<td class="data p5px">DLX</td>
				<td class="data p5px">34999</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Cancellation Policy:</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="data p5px">Timelines</td>
				<td class="data p5px">Penalty</td>
			</tr>
			<tr>
				<td class="data p5px">45 or more days prior to departure</td>
				<td class="data p5px">25% of package cost will be charged as penalty.</td>
			</tr>
			<tr>
				<td class="data p5px">Within 30 days before departure.</td>
				<td class="data p5px">100% of package cost will be charged as penalty</td>
			</tr>
		</table></div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.anmolparyatan.co.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Ladakh Fixed Departure Package - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>
						<a href="#" onclick="document.getElementById('frmpackagedetail').submit();" class="button p7px pl12px pr12px c5px b large dib mt10px">Book Your Tour</a>
						<input type="hidden" name="pkg_slno" value="137954"/>
						</form>
						</div>
						
						";i:1;s:69:"Book Ladakh Fixed Departure Package - 6 Nights / 7 Days Tour Packages";i:2;s:123:"book ladakh fixed departure package - 6 nights / 7 days tour packages, hill station tour packages, leh ladakh tour packages";i:3;s:154:"Anmol Paryatan offers Ladakh Fixed Departure Package - 6 Nights / 7 Days tour package, budget Hill Station tour packages for Leh Ladakh at exciting price.";i:4;s:817:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Leh Ladakh"        
		                 },
		      "description": "Meals other than those specified above
Personal expenses like portages, tips, laundry, mineral water etc.
Monument entrances, camera charges, etc.
Any activity not mentioned in the inclusions
Travel Insurance
Additional cost due to flight cancellation/ roadblocks, Political unrest etc.
Additional cost of Hotel to be borne by customer in case of road blockage due to snow. (Enroute Nubra & Pangong)",
		      "name": "Ladakh Fixed Departure Package",
		      "telephone": "+91-9819800504"
		    }
		    </script>
			";i:5;N;}