a:6:{i:0;s:13928:"				<div class="h1"><h1>Kullu - Manali Holidays Package</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.himalayannavigators.in/" title="Home">Home</a> 
				
								
				<b class="ffv p2px">&rsaquo;</b>Kullu - Manali Holidays 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">
						4 Nights / 5 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Manali</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 4999 Per Person						</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.himalayannavigators.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Kullu - Manali Holidays 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="24137"/>
						</form>
						</p>
						</td>
						</tr>
											</table>
					</td>
											<td class="p10px vat imgWidth150 w150px lh0">
						<div class="demo-wrap">
						<ul class="lsn m0px p0px" id="detailslider1">
															<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_10/292604/46779.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/46779.jpg"  width="150" height="150"    alt="Kullu - Manali Holidays Package" title="Kullu - Manali Holidays Package" /></a></p></div></li>
																		<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_10/292604/46780.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/46780.jpg"  width="150" height="150"    alt="Kullu - Manali Holidays Package" title="Kullu - Manali Holidays Package" /></a></p></div></li>
																		<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_10/292604/46781.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/46781.jpg"  width="150" height="150"    alt="Kullu - Manali Holidays Package" title="Kullu - Manali Holidays Package" /></a></p></div></li>
																		<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_10/292604/46782.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/292604/46782.jpg"  width="150" height="150"    alt="Kullu - Manali Holidays Package" title="Kullu - Manali Holidays Package" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Manali at an altitude of 2,050 meters ((6,726 ft) in the Beas River Valley is a hill station nestled in the mountains of the Indian state of Himachal Pradesh near the northern end of the Kullu Valley. Manali is primary attraction for the tourists who want to visit the Himalayas. Rohtang Pass is very much popular among tourists. Beas River nearby Kullu also offers opportunities for rafting. Manali is also known as adventures paradise and offer various adventure activities too.Package Exclusion:<br />
Any Air fare/Train fare.<br />
Any type of transportation excluding the provided sightseeing as per itinerary.<br />
Any meals other then specified in above package inclusion.<br />
Monuments entry fees/camera fees/Guide fees/entertainment fees.<br />
Expenses of personal nature such as telephone calls, laundry, liquor etc.<br />
Heater charges at hotel will be extra.<br />
Any other which is not specified in above package Inclusion.<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> Delhi - Manali (570 KM, 13 - 14 hrs)
								</p>
								<p class="aj">Board our Ac Volvo Bus from Delhi for your onward journey to Manali. It Will be your overnight journey to reach Manali.<br />
<br />
Boarding Time: 1700 Hrs.<br />
Departure Time: 1730 Hrs<br />
<br />
Be at Volvo Boarding point on tentative date and Time</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> Manali Arrival - Local Manali sightseeing tour
								</p>
								<p class="aj">Upon arrival at Manali bus stand our cab will pick you and transfer to your hotel. Same day in afternoon proceed to Half Day Manali city sightseeing tour. Visit Hadimba Temple, unique for its pagoda architectural design located in the midst of a very old pine Forest and Club House. After that Visit the Vashist Sulfur Hot Water Spring, and then to Tibetan Monastery and Van Vihar located at the heart of the Manali.  Evening return back to hotel. rest free to leisure and Independent activities. Dinner & Overnight stay at hotel. <br />
</p>					
									<p><b>Meals : </b> Dinner</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> Rohtang Pass Up To Snow Line sightseeing tour (51 km)
								</p>
								<p class="aj">Today after breakfast drive to Rohtang Pass/ Snow Point. The total distance is 51 km, Situated at an altitude of 4,111 meters (13,400 ft) above from sea level on the NH 21 to Leh. Here one can sees the majesty of the mountains at its height and splendor. At the top of the Pass the air seems to glitter against the snow as you look down over herringboned ridges into the Lahaul Valley. Enroute visit Kothi Gorge, Gulaba, Rahala Falls, Marhi and Solang Valley and enjoy skiing, paragliding and other adventurous activities (package cost does not include any of such activates). Return to hotel by evening. Overnight stay at hotel. <br />
 </p>					
									<p><b>Meals : </b> Breakfast, Dinner</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> Manikaran or Nagar Castle Sightseeing (optional Sightseeing)
								</p>
								<p class="aj">Morning leave for Manikaran, total distance is 85 km. Full day excursion visiting Kullu, Vaishno Devi temple, Angora farm, Kasol valley, Manikaran hot water spring, Shiva temple, Gurudwara and Rama temple. Manikaran has the World’s hottest Sulfur Spring Waters and is a holy place for Hindus & Sikhs alike. If you are adventure lover Enjoy White Water rafting on the way to Manikaran at your own cost (package does not include). Evening Proceed back to Manali. <br />
<br />
or<br />
<br />
Today Morning after breakfast proceed to Nagar - Kullu sightseeing. Visit Nagar Castle, Nicolas Rorich Art Gallery and The Museum at Nagar. On the way visit Ancient Sandhta Gaytri Temple and Shiva Temple at Jagatsukh. After that proceed back to Manali.  Rest of the at Leisure. Overnight stay at Hotel.<br />
  </p>					
									<p><b>Meals : </b> Breakfast, Dinner</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> Manali (Departure) - Delhi 
								</p>
								<p class="aj">Morning check out from hotel and transfer to Mall road, explore the local market and shops at Mall Road. Stroll over the Mall Road till your departure. Board Volvo for your journey back to Delhi by evening. <br />
<br />
Boarding Time: 1600 Hrs.<br />
Departure Time: 1630 Hrs.<br />
<br />
Back in Delhi on next day morning between 8 to 9 am.</p>					
									<p><b>Meals : </b> Breakfast</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>Sightseeing</li>
																		<li>Transport</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Package Exclusion:</li><li>
Any Air fare/Train fare.</li><li>
Any type of transportation excluding the provided sightseeing as per itinerary.</li><li>
Any meals other then specified in above package inclusion.</li><li>
Monuments entry fees/camera fees/Guide fees/entertainment fees.</li><li>
Expenses of personal nature such as telephone calls, laundry, liquor etc.</li><li>
Heater charges at hotel will be extra.</li><li>
Any other which is not specified in above package Inclusion.</li></ul><br />
												<p class="large b mb5px dif">Departure Cities with rates :</p>Delhi<br /><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>~^#^~~^#^~<ul>
	<li>Cancellation of booking is subject to the rules &amp; regulation of the hotel &amp; our service charges are concerned by hand on such cancellation.</li>
	<li>Postponement of date will be treated as cancellation and will be subject to availability.</li>
	<li>All disputes are Subject of Manali Jurisdiction.</li>
</ul>

<p><strong>Meal Plans:-</strong>

<ul>
	<li>EPAI : Room Only</li>
	<li>CPAI : Room + Breakfast</li>
	<li>MAPAI : Room + Breakfast and one major meal</li>
	<li>AP : Room + All Meals.</li>
	<li>Facilities like use of heater at hotel rooms in Himachal Pradesh will be chargeable as per Hotel policies.</li>
	<li>Check in &amp; Check out Time will be 12 AM, if client need room early then it will be as per availability at hotel.</li>
	<li>If the desired hotel is not available due to any reason; however Himalayan Navigators will reserve another similar category hotel with to its customer</li>
	<li>Rates are subject to change without prior notice.</li>
	<li>No Refund will be granted on cancellation of hotel / package.10.</li>
	<li>On cancellation of any package or hotel reservation, booking payment will not be refundable or transferable.</li>
	<li>AC in cab during hills would not be operated.</li>
	<li>Please be careful with your personal belongings.</li>
	<li>Major Sight Seeing point Rohtang Pass are closed on Tuesday every week.</li>
	<li>Due to any inclement weather condition at Himachal, we are not liable for any kind of refund.</li>
	<li>Under Volvo tours pickup service are not included from Airport / Station to Bus Point and from Bus Point to Hotel. Under Volvo tours pickup service are included from Volvo arrival point at Manali to your Hotel.</li>
	<li>&ldquo;Himalayan Navigators &ldquo; is registered with Department of Tourisum and Civil Aviation Government of Himachal Pradesh, and will not be responsible for any loss or damage to person life or Any kind of issue faced during tour, its compulsory to intimate us during that time of tour only, so that it can be rectified.</li>
	<li>After the tour is complete, we are not liable for any kind of refund.</li>
</ul>												</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.himalayannavigators.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Kullu - Manali Holidays 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="24137"/>
						</form>
						</div>
						
						";i:1;s:70:"Book Kullu - Manali Holidays Package - 4 Nights / 5 Days Tour Packages";i:2;s:114:"book kullu - manali holidays package - 4 nights / 5 days tour packages, valley tour packages, manali tour packages";i:3;s:166:"Book Kullu - Manali Holidays Package - 4 Nights / 5 Days tour packages from Himalayan Navigators - Get attractive 4 Nights / 5 Days Valley  tour packages for  Manali.";i:4;s:1316:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Manali"        
		                 },
		      "description": "Manali at an altitude of 2,050 meters ((6,726 ft) in the Beas River Valley is a hill station nestled in the mountains of the Indian state of Himachal Pradesh near the northern end of the Kullu Valley. Manali is primary attraction for the tourists who want to visit the Himalayas. Rohtang Pass is very much popular among tourists. Beas River nearby Kullu also offers opportunities for rafting. Manali is also known as adventures paradise and offer various adventure activities too.Package Exclusion:
Any Air fare/Train fare.
Any type of transportation excluding the provided sightseeing as per itinerary.
Any meals other then specified in above package inclusion.
Monuments entry fees/camera fees/Guide fees/entertainment fees.
Expenses of personal nature such as telephone calls, laundry, liquor etc.
Heater charges at hotel will be extra.
Any other which is not specified in above package Inclusion.",
		      "name": "Kullu - Manali Holidays Package",
		      "telephone": "+91-8091208888"
		    }
		    </script>
			";i:5;N;}