a:6:{i:0;s:19582:"				<div class="h1"><h1>Himachal Tour With 4 Adults</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.tanishhimachaltours.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.tanishhimachaltours.com/travel-packages.htm" title="Travel Packages">Travel Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Himachal Tour With 4 Adults</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">
						7 Nights / 8 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">New Delhi, Manali, Shimla, Kinnaur, Lahaul & Spiti</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 18500 Per Person						</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.tanishhimachaltours.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Himachal Tour With 4 Adults - 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="128026"/>
						</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_15/438757/205169.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/438757/205169.jpg"  width="150" height="150"    alt="Himachal Tour With 4 Adults" title="Himachal Tour With 4 Adults" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Meal plan : Lunch <br />
NON VEG MEAL<br />
Cabs : Non-AC <br />
Airfare <br />
Others : Other Exclusions (Car at disposal <br />
All kind of personal expenses such as tips, laundry, telephone bills and beverages.It also does not include any meals unless and otherwise specifically mentioned.. <br />
Optional, suggested or unspecified activities. <br />
Camera fee (still or movie)<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> ARRIVAL
								</p>
								<p class="aj">After arriving at the Delhi airport, our cab meets you and helps you with an assisted transfer to Shimla and enjoy zig zag curves and beauty of forests in between kalka to shimla . after reach at shimla . check-in at the hotel. Fondly referred to as the “Queen of Hills’ Shimla is the capital city of Himachal Pradesh, former summer capital of British India & now a capital of Himachal Pradesh, set amidst the snow capped shivalik mountain ranges offering some stunning views of the mighty Himalayas,which boasts of mesmerizing scenery and a laid-back atmosphere.During your leisure time, explore the nearby places on your own such as visiting the Mall, the Ridge,Jakhoo temple,viceregal lodge and so on. Stay overnight at shimla. <br />
- Jakhoo <br />
- The Mall <br />
- Christ church <br />
- Lakkar Bazaar</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> SHIMLA NARKANDA SANGLA
								</p>
								<p class="aj">After breakfast local sight seen of Narkanda.In Narkanda we visit Hatu and Tannu Jubbar lake. The Hatu Peak is one of the highest peaks in Narkanda and offers a panoramic view of the beautiful valley below., After local enjoy move our wheels towards Sangla. Overnight stay at sangla.</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> SANGLA NAKO TABO
								</p>
								<p class="aj">Early in the morning, witness the beautiful sunrise over the Kinnaur Kailash Peaks. After that drive to Tabo. On your way, visit Kinnaur’s most picturesque hamlet and the Nako Lake. Nako is a heritage village built around a small lake and has an important Buddhist Gompa and a small temple. A footprint like impression on a rock is ascribed to the saint Guru Padmasambhava. Explore the scenic Spiti Valley that has few signs of vegetation. The beauty of Spiti lies in its unspoiled, untainted raw landscape. Rudyard Kipling describes Spiti in ‘Kim’ in these words: “At last they entered a world within a world - a valley of leagues where the high hills were fashioned of the mere rubble and refuse from off the knees of the mountains…surely the Gods live here.” On arrival at Tabo, check in to the hotel. The ancient village of Tabo is situated on the left bank of the river Spiti. It is the land of one of the most famous Buddhist monasteries, regarded next to the Tholong Gompa in Tibet. It is also known as the ‘Ajanta of Himalayas’.Dinner & O/N Stay into the Hotel at Tabo.</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> TABO KAZA
								</p>
								<p class="aj">Join the morning prayers at the Tabo Monastery which was constructed in 996 AD. It is a complex that consists of 9 Temples, 23 Chortens, a monk’s chamber and an extension that houses the nun’s chamber. Above the enclave is a series of caves which are used by the monks. The monastery contains large number of scriptures and pieces of art including wall paintings and stucco. There is also a modern Gompa and a painting school founded by the Dalai Lama. Check out of the hotel in Tabo and head to Kaza (3870 metres above sea level). On your way to Kaza (the capital of Spiti Valley), visit Dhankar Gompa, the traditional capital of Spiti. This hilltop fort that overlooks the Spiti Valley used to be a jail earlier. Today, more than 160 lamas reside here. Notable sights at Dhankar Gompa include a statue of Vairochana (Dhayan Buddha) consisting of 4 figures seated back to back in addition to various crumbling Thangkas. Also enjoy to visit Pin Valley on the way. Enjoy to see the beautiful valley gifted by God to Himachal Pradesh. Evening time reached at Kaza. On arrival at Kaza, check in to the hotel & a comfortable overnight stay & Dinner at the Kaza.</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> KAZA CITY TOUR
								</p>
								<p class="aj">Early in the morning after breakfast get ready for visit local sight-seeing. Visit to Ki Monastery, Kibber Village, Comick Village & nature of beautiful Kaza. Full day sight- seeing and back to hotel. Dinner & O/N stay into hotel at Kaza. KIBBER VILLAGE Kibber also Kyibar is a village high in the Spiti Valley in the Himalayas at 4270 metres or 14,200 ft in Himachal Pradesh in northern India. It contains a monastery and the Kibber Wildlife Sanctuary. Kibber lies in a narrow valley on the summit of a limestone rock. It is located 16 kilometers from Kaza and a bus service connects them in the milder summer months. Agriculture forms the backbone of the local economy and lush green fields are abundant. Villagers count on the 3 day traditional trade route over Parang La to Ladakh to barter their horses for yaks or to sell for cash. The village has around 80 houses, unique, given that they are made of stone instead of mud or adobe brick used extensively elsewhere in the Spiti valley. Kibber has a civil dispensary, a high school, a post office, a telegraph office and a community TV set in the village. Kibber Monastery was founded by Serkang Rimpochhe of Tabo. Ki Monestry Kye Gompa (also spelled Ki, Key or Kee - pronounced like English key) is a Tibetan Buddhist monastery located on top of a hill at an altitude of 4,166 metres (13,668 ft) above sea level, close to the Spiti River, in the Spiti Valley of Himachal Pradesh, Lahaul and Spiti district, India. It is the biggest monastery of Spiti Valley and a religious training centre for Lamas. It reportedly had 100 monks in 1855. Arrive Kaza in Evening and check into the Hotel. Dinner and O/N stay in kaza.</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> KAZA CHANDERTAL - KAZA NAKO
								</p>
								<p class="aj">After breakfast start early from Kaza, travel to ChanderTal Lake via Kunzum la pass.Today we will trek 18 kms from Batal to reach Chandratal and it will take us about 5- 6 hrs, while on this trek we will get a nice view of the Lahaul range, peaks like Minar(6172 M), Talagiri(6279 M), Tara Pahar(6227 M) and Mulkila (6517 M). Dinner and overnight stay in tents..Overnight stay at the chandertal camps <br />
OR <br />
After breakfast leave for Nako, get ready for visit to another valley of Nako. After arrival see another beauty of nature. In afternoon visit back to Nako. In evening reach Nako check into the hotel. Dinner at stay at Nako.</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> NAKO NARKANDA - CHANDERTAL MANALI
								</p>
								<p class="aj">Early in the morning after breakfast get ready for visit to another valley of Sangla And drive to Narkabda. Arrive Narkanda and visit to Hatu Peak in Narkanda. HATU PEAK Hatu Peak lies on the top of the peak is a small wooden temple called Hatu temple.<br />
According to local belief the famous Hatu Mata temple is the temple of ‘Mandodari’ wife of ‘Ravana’. People come in great number on the first Sunday of Jyeshtha to pay ritual here. <br />
Goat sacrifice is still in practice near the temple.There is an ancient stove like formation of rocks nearby the temple. Locals believe that it was used by the Pandavas brothers to cook their food during their Agyaat Vaas. In evening back to Narkanda. Check into the hotel.<br />
Dinner & O/N stay into the hotel at Narkanda. <br />
OR <br />
After Breakfast we move towards Manali ontour we visit Rohtang.Rohtang pass(situated at the height of 3978 meters on eastern Pir Panjal range of the Himalyas, about 51 km from Manali connects the Kullu valley with the Lahul and Spiti valley) ,on the way sight - seeing at Nehru kund, Rahla falls, Enjoy the scenic view of snow covered peaks at Rohtang / ,Solang valley and after rohtang Check into hotel Manali.overnight stay at Manali.</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 8:</b> NARKANDA DELHI - MANALI DELHI
								</p>
								<p class="aj">After breakfast checkout from hotel and transfer to Delhi Airport or railway station to board the flight /train for onward destination.<br />
Tour Ends !!!!!!!!!</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>Meal plan : Breakfast and Dinner</li><li>
Cabs : AC ( Note : A/C will won’t be operational in hills )</li><li>
Vehicle - Innova</li>
													</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Meal plan : Lunch </li><li>
NON VEG MEAL</li><li>
Cabs : Non-AC </li><li>
Airfare </li><li>
Others : Other Exclusions (Car at disposal </li><li>
All kind of personal expenses such as tips, laundry, telephone bills and beverages.It also does not include any meals unless and otherwise specifically mentioned.. </li><li>
Optional, suggested or unspecified activities. </li><li>
Camera fee (still or movie)</li></ul><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>~^#^~~^#^~<ul>
	<li>The rates are subjects to change without any prior notice. - Accommodation in the itinerary at the mentioned hotels or the similar hotels.</li>
	<li>The confirmation is subjects to availability. - Cost incidental to any change in the itinerary/ stay on account of flight cancellation due to bad Weather, ill health, strike, roadblocks and/or any factors beyond control. - It is a suggestion for you that please book this offer as soon as possible because we are not holding any booking and it is totally depend on the availability of rooms and flight.</li>
	<li>From the booking date till 30 days prior to the departure date, 30 % of the package cost is chargeable.</li>
	<li>From 30 days to 15 days prior to the departure date, 50 % of the package cost is chargeable.</li>
	<li>From 15 days to 7 days prior to departure date, 75 % of the package cost is chargeable.</li>
	<li>For cancellations made within 5 days prior to the departure date, 100% of the package cost is chargeable.</li>
	<li>No refund will be made for any unused accommodation, missed meals, transportation segments, sightseeing tours or any other service due to Bad weather, ill health, Strike, Road Blocks or any other factor beyond our Control. Such unused items are neither refundable nor exchangeable. - Room allocation is done by the hotel depending upon availability at the time of check - in. the category of room as specified on your confirmation voucher.</li>
	<li>No refund shall be claimed, if the services &amp; amenities of hotel were not up to your expectations, it will be considered on case to case basis.</li>
	<li>Room Heater charges will be extra charged as per hotel rates in every hotel.</li>
	<li>Meal plan will be veg in every hotel.( Non veg will be included on travellers request ).</li>
	<li>Rohtang Pass Permit and sighscene will be provided as per govt. Terms and conditions.</li>
	<li>Below 5 Years child will be complementry.More then 5 yrs Child will be charged as adults cost13. All payments of package cost should be cleared before Last day check out of the tour.</li>
</ul>						
    	<p class="h dif xlarge b mb5px">Cost</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">CHECK-IN</td>
				<td class="headHr p5px b">CHECK-OUT</td>
				<td class="headHr p5px b">NIGHTS</td>
				<td class="headHr p5px b">LOCATION</td>
				<td class="headHr p5px b">HOTEL NAME</td>
				<td class="headHr p5px b">ROOM TYPE</td>
				<td class="headHr p5px b">MEAL PLAN</td>
			</tr>
			<tr>
				<td class="data p5px">5 May 2018</td>
				<td class="data p5px">6 May 2018</td>
				<td class="data p5px">1</td>
				<td class="data p5px">Shimla</td>
				<td class="data p5px">Hotel Auckland</td>
				<td class="data p5px">Deluxe</td>
				<td class="data p5px">Mapi</td>
			</tr>
			<tr>
				<td class="data p5px">6 May 2018</td>
				<td class="data p5px">7 May 2018</td>
				<td class="data p5px">1</td>
				<td class="data p5px">Sangla</td>
				<td class="data p5px">Hotel Madhu</td>
				<td class="data p5px">Deluxe</td>
				<td class="data p5px">Mapi</td>
			</tr>
			<tr>
				<td class="data p5px">7 May 2018</td>
				<td class="data p5px">8 May 2018</td>
				<td class="data p5px">1</td>
				<td class="data p5px">Tabo</td>
				<td class="data p5px">Tow Dhey Himalaya</td>
				<td class="data p5px">Deluxe</td>
				<td class="data p5px">Mapi</td>
			</tr>
			<tr>
				<td class="data p5px">8 May 20188 May 2018</td>
				<td class="data p5px">10 May 2018</td>
				<td class="data p5px">2</td>
				<td class="data p5px">Kaza</td>
				<td class="data p5px">Travellers Shed</td>
				<td class="data p5px">Deluxe</td>
				<td class="data p5px">Mapi</td>
			</tr>
			<tr>
				<td class="data p5px">10 May 2018</td>
				<td class="data p5px">10 May 2018</td>
				<td class="data p5px">1</td>
				<td class="data p5px">Nako</td>
				<td class="data p5px">Hotel Himalayan</td>
				<td class="data p5px">Deluxe</td>
				<td class="data p5px">Mapi</td>
			</tr>
			<tr>
				<td class="data p5px">10 May 2018</td>
				<td class="data p5px">12 May 2018</td>
				<td class="data p5px">1</td>
				<td class="data p5px">Nako</td>
				<td class="data p5px">Shyam Regency</td>
				<td class="data p5px">Deluxe</td>
				<td class="data p5px">Mapi</td>
			</tr>
		</table></div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.tanishhimachaltours.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Himachal Tour With 4 Adults - 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="128026"/>
						</form>
						</div>
						
						";i:1;s:66:"Book Himachal Tour With 4 Adults - 7 Nights / 8 Days Tour Packages";i:2;s:160:"book himachal tour with 4 adults - 7 nights / 8 days tour packages, hill station tour packages, new delhi, manali, shimla, kinnaur, lahaul & spiti tour packages";i:3;s:213:"Book Himachal Tour With 4 Adults - 7 Nights / 8 Days tour packages from Tanish Himachal Tours - Get attractive 7 Nights / 8 Days Hill Station  tour packages for  New Delhi, Manali, Shimla, Kinnaur, Lahaul & Spiti.";i:4;s:796:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "New Delhi, Manali, Shimla, Kinnaur, Lahaul & Spiti"        
		                 },
		      "description": "Meal plan : Lunch 
NON VEG MEAL
Cabs : Non-AC 
Airfare 
Others : Other Exclusions (Car at disposal 
All kind of personal expenses such as tips, laundry, telephone bills and beverages.It also does not include any meals unless and otherwise specifically mentioned.. 
Optional, suggested or unspecified activities. 
Camera fee (still or movie)",
		      "name": "Himachal Tour With 4 Adults",
		      "telephone": "+91-9736035555"
		    }
		    </script>
			";i:5;N;}