a:6:{i:0;s:22609:"				<div class="h1"><h1>Mystique Himachal 9 Night/10 Days Package</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.chaturveditravels.com/" title="Home">Home</a> 
				
								
				<b class="ffv p2px">&rsaquo;</b>Mystique Himachal 9 Night/10 Days 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">Tour Code </td>
						<td class="p5px pl0px vat">CTT30/Amritsar-Chand</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						9 Nights / 10 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Chandigarh, Dalhousie, Dharamshala, Katra, Amritsar</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 31500 Per Person						</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.chaturveditravels.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Mystique Himachal 9 Night/10 Days 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="27825"/>
						</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_8/229281/56056.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_8/229281/56056.jpg"  width="150" height="150"    alt="mystique himachal" title="mystique himachal" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					2 Nights Amritsar - 1 Night Chandigarh - 2 Nights Dalhousie - 2 Nights Dharamshala - 2 Nights -KatraAny Airfare, Train fare, Overland Journey which is not mentioned in the Itinerary.<br />
Any personal nature items like Laundry, bar bills, table bills, camera fee, tips or any other item.<br />
Major Meals i.e. Lunch & Dinner at katra /Chandigarh / Amritsar.<br />
Guide / Entry fees, Boatings, Elephant riding / Horse ridings etc. During sight seeings.<br />
Any Medical /rescue evacuation due to mishaps.<br />
Optional Activities mentioned in the itinerary.<br />
Any other things that is not included in the Package Cost Includes Column.<br><br>Note:<br />
Any changes in Govt. taxes, Hotel Tariff, etc will be intimated before confirming the Package.<br />
Cost incidental to any change in the itinerary/ stay on account of flight cancellation due to bad weather, ill health, roadblocks and/or any factors beyond control.<br />
Government Service tax @ 3.09 Extra.<br />
Every passenger is traveling on his own.<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 - Amritsar (500kms - 10hrs)
								</p>
								<p class="aj">Travel by surface from Delhi to Amritsar<br />
<br />
Amritsar : The city of Amritsar is a glittering showcase of compound traditions and secular culture. A thriving city with important devout centers and historical sites Amritsar exhibits a glorious past, magnificient present and a hopeful future.<br />
<br />
Arrive at Amritsar , Then transfer to hotel check in to hotel.take rest overnight stay at hotel at Amritsar.</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> Amritsar Local
								</p>
								<p class="aj">After Breakfast visit to the city tour with the blessings of Golden Temple-the most important Sikh shrine which is also called Mecca for the Sikhs is a living symbol of the spiritual and historical traditions of the Sikhs.Then visit Jallianwala Bagh- where, on April 13, 1919, British and Gurkha soldiers opened fire on an unarmed forbidden gathering, killing hundreds of civilians,<br />
<br />
Evening visit to Indo-Pak Wagah Border to watch Flag Retreat Ceremony- Wagah, an army outpost on Indo-Pak border 30 Kms from Amaritsar where the daily highlight is the evening "Beating the Retreat" ceremony. Later evening back to hotel and free for leisure, overnight stay at hotel at Amritsar.</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> Amritsar - Katra (260km - 6 - 7hrs)
								</p>
								<p class="aj">After Breakfast visit to the city tour with the blessings of Golden Temple-the most important Sikh shrine which is also called Mecca for the Sikhs is a living symbol of the spiritual and historical traditions of the Sikhs. Then visit Jallianwala Bagh- where, on April 13, 1919, British and Gurkha soldiers opened fire on an unarmed forbidden gathering, killing hundreds of civilians, Later drive to Katra.<br />
<br />
Katra : Vaishno Devi, as it is popularly known, is a small town in Reasi district of the Indian state of Jammu and Kashmir situated in the foothills of the Trikuta Mountains, where the holy shrine of Vaishno Devi is located.<br />
<br />
On arrival at Katra checkin to hotel. Rest of the day free at lesuire .Overnight stay at hotel at Katra.</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> Katra - Maa Vaishno Devi (16 km track ) - Katra
								</p>
								<p class="aj">After Breakfast or without Breakfast visit to the Hoy Yatra towards the Holy shrine of Maa Vaishno Devi Jee Bhawan, firsty we will go to banganga (Heli pad, Helicopter, pony, Palki etc used by Your own cost) then we can go by helicopter or pony, palki or by foot to vaishno devi Mandir).<br />
<br />
Vashno devi darshan: As per the legend, during the period when the Goddess was busy in annihiliting the Asuras, Her three main manifestations viz. Mata Maha Kali, Mata Maha Lakshmi and Mata Maha Saraswati got together one day and pooled their collective Tejas or spiritual strength. A stunningly bright light emanated from the place where the Tejas of the three manifestations coalesced and a beautiful young girl emerged out of this Tejas. The young girl asked them, "Why have I been created?'' The Devis explained to her that they had created her so that she would live on earth and spend her time in upholding righteousness.<br />
<br />
After Darshan later back to the Katra,overnight stay at hotel at katra.</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> Katra - Dalhousie(240kms. - 7hrs)
								</p>
								<p class="aj">After Breakfast check out from hotel then drive to Dalhousie<br />
<br />
Dalhousie : is a beautiful, quiet and peaceful small town of North India, famous among the honeymooners. Away from the maddening crowds of plains, Dalhousie is surrounded with attractive cottages, villas, sky touching deodar and pine trees and evergreen ornamental shrubs that makes it one of the most preferred tourists destination in Himachal Pradesh.<br />
<br />
On arrival at Dalhousie check in to the hotel.Rest of the day is free for leisure. You can enjoy a walk along the mall road, later back to hotel,free for leisure , overnight stay at hotel at Dulhousie.</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> Dalhousie - Khajjiar - Chamba (42kms - 1.30hrs) - Dalhousie
								</p>
								<p class="aj">After breakfast visit to Khajjiar Sanctuary - Gandhi Chowk - Khajinag Temple.<br />
<br />
Khajjiar known as Mini Switzerland of India, "Khajjiar is a forest glade of great beauty, 6400 feet above sea level", there after towards Chamba and after full day excursion later back to Dalhousie .then free for leisure, overnight stay at hotel at Dalhousie.<br />
<br />
Also visit Chamba covering the famous Luxmi Narayan Temple (Ancient and Historical Temple) and the Chamunda Temple (famous for its ancient wooden carving) both are the sidh piths of Chamba and Museum.<br />
<br />
Later back to hotel, Rest of the day free at leisure. overnight stay at hotel at Dalhousie.</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> Dalhousie - Dharamsala (150kms - 5hrs)
								</p>
								<p class="aj">After breakfast check out from hotel then drive to Dharmshala.<br />
<br />
Dharamshala : This is a hill station lying on the spur of the Dhauladhar range about 17 kms north- east of Kangra town. This hill station is wooded with oak and conifer trees and snow capped mountains enfold three sides of the town while the valley stretches in front. The snowline is perhaps more easily accessible at Dharamshala than at any other hill resort and it is possible to make a day's trek to a snow-point after an early morning's start. Dharamshala is also the headquarter of the Kangra district.<br />
<br />
Arrive at Dharamshala,check in to hotel, Rest of the day free for leisure . overnight stay at hotel in Dharamshala.</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> Dharamsala - palampur (40 kms) - Dharamsala
								</p>
								<p class="aj">After breakfast, Visit to Mc Leodganj and Palmpur Tea Eatates :Gorgeous, pretty and enchanting, these words would not suffice to express the ethereal beauty of Palampur, which is renowned for its fine quality of tea and celestial ambiance. A hilly resort with pristine surroundings, Palampur is nested within the majestic mountain peaks of Dhauladhar Ranges in the Kangra Valley. this sky resort flaunts a dazzling picture of light and shade with its terraced paddy fields, aromatic tea Garden and the deep woods. The name Palampur is a derivative of the term Palam, which means abundant water, a name that is aptly suited to the magnificent environ of numerous pour outs and torrents that interlaces the winding paths of the lush terrain of Palampur. Formerly Palampur was part of the Sikh Kingdom of Jalandhara and it came to limelight only in the 19th century when the British noticed its aromatic freshness and salubrious climate. As a matter of fact, the progressive Englishmen made this sleepy hamlet into a bustling center of trade and commerce, etc.<br />
<br />
Later back to hotel. Rest of the day free to enjoy at mall road ,overnight stay at hotel in Dharamsala.</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 9:</b> Dharamshala - Chandigarh (260kms 6 - 7hrs)
								</p>
								<p class="aj">After breakfast check out from hotel then drive to Chandigarh.<br />
<br />
Chandigarh: Picturesquely located at the foothills of Shivaliks, the Union territory of Chandigarh serves as the capital of Punjab and Haryana. The city derives its name from the temple of "Chandi Mandir" located in the vicinity of the site selected for the city. The deity 'Chandi', the goddess of power and a fort 'garh' beyond the temple gave the city its name "Chandigarh-The City Beautiful".Known internationally for its architecture and urban planning,<br />
<br />
Arrive at Chandigarh,check in to hotel, take rest.free at leisure. overnight stay at hotel at Chandigarh.</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 10:</b> Chandigarh - Delhi (260kms - 6hrs)
								</p>
								<p class="aj">After breakfast check out from hotel and Visit Rock Garden, Rose Garden And Sukhna Lake, Later drive towards Delhi. Evening arrive Delhi. Drop at railway station / 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>Sightseeing</li>
																		<li>Transport</li>
																		<li>Transfers</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Any Airfare, Train fare, Overland Journey which is not mentioned in the Itinerary.</li><li>
Any personal nature items like Laundry, bar bills, table bills, camera fee, tips or any other item.</li><li>
Major Meals i.e. Lunch & Dinner at katra /Chandigarh / Amritsar.</li><li>
Guide / Entry fees, Boatings, Elephant riding / Horse ridings etc. During sight seeings.</li><li>
Any Medical /rescue evacuation due to mishaps.</li><li>
Optional Activities mentioned in the itinerary.</li><li>
Any other things that is not included in the Package Cost Includes Column.<br><br>Note:</li><li>
Any changes in Govt. taxes, Hotel Tariff, etc will be intimated before confirming the Package.</li><li>
Cost incidental to any change in the itinerary/ stay on account of flight cancellation due to bad weather, ill health, roadblocks and/or any factors beyond control.</li><li>
Government Service tax @ 3.09 Extra.</li><li>
Every passenger is traveling on his own.</li></ul><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>~^#^~~^#^~<ul>
	<li>Per person rates (Rs) - Applicable on 3 / 4 persons staying together sharing the same room</li>
	<li>Package rates are subject to change without prior notice<br />
	Meal plan: EP- accommodation only, CP-accommodation with breakfast, MAP- accommodation with breakfast, lunch or dinner, AP-accommodation with breakfast, lunch &amp; dinner</li>
	<li>The packages can not be combined with any other offer.<br />
	The above package is not valid during national holidays, festivals &amp; long weekends Chaturvedi Travels and Tours. Reserves the right to change/modify or terminate the offer any time at its own discretion and without any prior notice Package does not includes</li>
	<li>Meals not mentioned in the itinerary. Package does not include entry fees to monuments and places anything not mentioned in the package includes. Porte rage at hotels and airports, tips, insurance, laundry, liquors, wine, mineral water, telephone charges all items of personal nature.</li>
	<li>Any cost arising due to natural calamities like landslides, roadblocks, etc. (to be borne by the clients directly on the spot).</li>
	<li>Any increase in taxes or fuel leading to an increase in surface transportation &amp; land arrangements, which may come into effect prior to departure.</li>
	<li>Rates are subject to change &amp; Rooms are subject to availability. Peak season / Holiday surcharge will be applicable in case if there are any events. No reservation has been made till date. This is just a quotation. Final costing will be given at the time of confirmation. The above rate is valid only for mentioned dates. The above is only an offer and not confirmation of your bookings.</li>
	<li>We shall proceed with your booking once we have receive the payment from you &amp; if we are not able to get the original hotels, shall provide equivalent/ alternative hotels. You are requested to make advance payment (50 % of the total tour cost) by credit card along with 2 % bank charges OR bank transfer to initiate with the bookings.</li>
	<li>Balance payment can be made 15 days prior to your tour starting date. On receipt of full payment we will send you the travel vouchers.</li>
	<li>PLEASE NOTE STANDARD CHECK IN TIME IS 1400 HRS &amp; CHECK OUT TIME IS 0900 HRS. PLEASE RECONFIRM THE ABOE PACKAGE WITH PAYMENT DETAILS AT THE EARLIEST. KINDLY DEPOSIT THE PACKAGE COST IN OUR ACCOUNT AT THE EARLIEST. PLEASE FIND OUR ACCOUNT DETAILS GIVEN BELOW CUSTOMER&#39;S OPTION TO MAKE PAYMENTS THROUGH DEBIT CLEARING Particulars Details.</li>
	<li>IN KEEPING WITH OUR HEIGHTENED SECURITY PROCEDURES WE REQUEST YOU TO CARRY A PHOTO-IDENTITY TO PRESENT AT CHECH-IN. FOREIGN NATIONALS WILL REQUIRETO PRESENT THE PASSPORT AND VALID VISA WHILE INDIAN NATIONALS CAN PRESENT ANY ONE OF THESE: PASSPORT, DRIVING LICENSE, VOTER ID CARD or PAN CARD. Our rates are based on the prevailing rates as negotiated by us with the hotels.</li>
	<li>Hotels retain the right to modify the rates without notice. In case of such changes the rates quoted before the modification, can be changed by us according to the modifications by hotels. All hotel bookings are based on usual check in and check out time of the hotels until unless indicated in the itinerary We shall not be responsible for any delays &amp; alterations in the program or expenses incurred - directly or indirectly - due to natural hazards, flight cancellations, accident, breakdown of machinery or equipments, breakdown of transport, weather, sickness, landslides, political closures or any untoward incidents.</li>
	<li>We shall not be responsible for any loss, injury or damage to person, property, or otherwise in connection with any accommodation, transportation or other services, resulting - directly or indirectly - from any act of GOD, dangers, fire, accident, breakdown in machinery or equipment, breakdown of transport, wars, civil disturbances, strikes, riots, thefts, pilferages, epidemics, medical or custom department regulations, defaults, or any other causes beyond our control.</li>
</ul>

<p><strong>Reservation Policy:</strong>

<ul>
	<li>Confirmation of Hotel Rooms / House boat is subject to the availability.</li>
	<li>Confirmation of the Packages is subject to receipt of 100% payment i.e., 70 % of the payment as advance at time of booking &amp; balance 30 % before 15 days of departure.</li>
</ul>

<p><strong>Cancellation Policy:</strong>

<ul>
	<li>Cancellation of the tour packages IS NON REFUNDABLE / Hotel Booking / Transportation or Non Utilization of the same: 100 % Retention.</li>
</ul>

<p><strong>Terms &amp; Conditions:</strong>

<p>The above itinerary is suggested Tour Plan. The Company is responsible for only those services which are charged from the guest. All other services which are not paid by the guest to the Company are Suggested services and Company is nowhere bound to provide that service or pay the cost for the same.

<ul>
	<li>Check in and Check out Timing of the Hotel will be according to the timing of the respective Hotels.</li>
	<li>Company is not responsible for compensating any loss or additional cost incurred by the guest while taking the tour.</li>
	<li>Company is not responsible, nor liable for any damage, loss or injury caused to any passenger while taking the tour.</li>
	<li>Dollar rates are applicable only to foreign nationals &amp; Indians possessing foreign passports, while the INR package rates will be applicable to Indian nationals.</li>
	<li>All the disputes are subject to Gwalior Jurisdiction only.</li>
	<li>Any Claim related to the Package must be brought to the notice of the Company within a week.</li>
</ul>												</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.chaturveditravels.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Mystique Himachal 9 Night/10 Days 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="27825"/>
						</form>
						</div>
						
						";i:1;s:81:"Book Mystique Himachal 9 Night/10 Days Package - 9 Nights / 10 Days Tour Packages";i:2;s:178:"book mystique himachal 9 night/10 days package - 9 nights / 10 days tour packages, lakes & rivers tour packages, chandigarh, dalhousie, dharamshala, katra, amritsar tour packages";i:3;s:223:"Chaturvedi Travels and Tours offers Mystique Himachal 9 Night/10 Days Package - 9 Nights / 10 Days tour package, budget Lakes & Rivers tour packages for Chandigarh, Dalhousie, Dharamshala, Katra, Amritsar at exciting price.";i:4;s:1431:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Chandigarh, Dalhousie, Dharamshala, Katra, Amritsar"        
		                 },
		      "description": "2 Nights Amritsar - 1 Night Chandigarh - 2 Nights Dalhousie - 2 Nights Dharamshala - 2 Nights -KatraAny Airfare, Train fare, Overland Journey which is not mentioned in the Itinerary.
Any personal nature items like Laundry, bar bills, table bills, camera fee, tips or any other item.
Major Meals i.e. Lunch & Dinner at katra /Chandigarh / Amritsar.
Guide / Entry fees, Boatings, Elephant riding / Horse ridings etc. During sight seeings.
Any Medical /rescue evacuation due to mishaps.
Optional Activities mentioned in the itinerary.
Any other things that is not included in the Package Cost Includes Column.<br><br>Note:
Any changes in Govt. taxes, Hotel Tariff, etc will be intimated before confirming the Package.
Cost incidental to any change in the itinerary/ stay on account of flight cancellation due to bad weather, ill health, roadblocks and/or any factors beyond control.
Government Service tax @ 3.09 Extra.
Every passenger is traveling on his own.",
		      "name": "Mystique Himachal 9 Night/10 Days Package",
		      "telephone": "+91-9826355115"
		    }
		    </script>
			";i:5;N;}