a:6:{i:0;s:84117:"				<div class="h1"><h1>Kailash Mansarovar Yatra - By Helicopter Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="https://www.grandindiatrip.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="https://www.grandindiatrip.com/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Kailash Mansarovar Yatra - By Helicopter Tour</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">Kailash Mansarovar Y</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						10 Nights / 11 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Kathmandu, Tibet, Banke</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 171999 Per Person						</td>
						</tr>
												<tr>
						<td class="b p5px dif w125px vat">Special Offer </td>
						<td class="p5px pl0px dif vat">Standard<br />
<br />
City	Hotel	No of Nights<br />
Kathmandu	Hotel Shankar / Park Village Or Similar	01<br />
Nepalgunj	Hotel Siddhartha Or Similar	01<br />
Simikot	Sun Valley Resort Or Similar	01<br />
Purang	Purang Hotel Or Similar	01<br />
Mansarovar	Mansarovar Guesthouse Or Similar	01<br />
Darchen	Hotel In Darchen Or Similar	01<br />
Diraphuk	Guest House In Dirapuk	01<br />
Zuthulphuk	Guesthouse In Zuthulphuk	01<br />
Hilsa	Hotel In Hilsa Or Similar	01<br />
Kathmandu	Hotel Shankar / Park Village Or Similar	01</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Kailash Mansarovar Yatra - By Helicopter Tour - 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="60811"/>
						</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_9/257644/114343.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/114343.jpg"  width="150" height="150"    alt="Kailash Mansarovar Yatra - By Helicopter" title="Kailash Mansarovar Yatra - By Helicopter" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					he world looks to India for answers to spiritual questions. Here great masters have established temples of learning that attracts seekers from all over. The walls of these holy places reverberate with the tinkling sounds of the bells and resonant chants fill the air.<br />
HIGHLIGHTS-<br />
Visit Pashupatinath Temple.<br />
Explore the holy Mt. Kailash and Mansarovar.<br />
<br />
* Ex - Kathmandu<br />
Kathmandu, Nepalgunj, Simikot, Manasarovar, Diraphuk, Zuthulphuk, Purang & Hilsa<br />
<br />
Pilgrimage<br />
In the northern part, there is a mighty mountain by the name Himalaya,<br />
<br />
Note.<br />
Arrival into and departure from Kathmandu Airport would be on your own arrangements.<br />
Do carry comfortable walking shoes.<br />
As per new rules, booking should be done 1 month in advance.<br />
Fullmoon Dates 2016 at Mansarovar/Kailash: May 21*, June 20*, July 19*, August 18*, September 16*.<br />
It is mandatory to carry a valid passport - validity 6 months before travel date and two copies of pp size photograph.<br />
Please contact our sales staff to give you best flight deals.<br />
The hotel confirmed will be as per the brochure or an alternate hotel of similar category.<br />
Itinerary is subject to change due to unavoidable circumstances and the extra cost incurred has to be paid by the clients.<br />
On Day 01, lunch will be served to guests checking in at the hotel by 1400 hours.<br />
Double sharing hotel in Nepalgunj and 3or 4pax in Simikot and Tibet.<br />
All sightseeing is subject to weather, political conditions in the destination.<br />
After the Mansarovar to Kailash; all the private vehicles are not allowed; So Yatri will be escorted by the ECO- buses only.<br />
Single occupancy will be applicable for 02 nights stay in Kathmandu only. Stay at rest of the places will be on twin / triple sharing.<br />
It is mandatory to carry a valid photo identity card (Passport / Driving Licence / Voter ID card).<br />
Transport from Kailash to Mansarovar will be by Eco Deluxe Bus, provided by the Tibet Tourism as no private vehicles are allowed in that particular region.<br />
'PL' denotes Packed Lunch.<br />
'L-LR' denotes Lunch at local restaurant.<br />
'EL' denotes en route Lunch.Standard<br />
<br />
City	Hotel	No of Nights<br />
Kathmandu	Hotel Shankar / Park Village Or Similar	01<br />
Nepalgunj	Hotel Siddhartha Or Similar	01<br />
Simikot	Sun Valley Resort Or Similar	01<br />
Purang	Purang Hotel Or Similar	01<br />
Mansarovar	Mansarovar Guesthouse Or Similar	01<br />
Darchen	Hotel In Darchen Or Similar	01<br />
Diraphuk	Guest House In Dirapuk	01<br />
Zuthulphuk	Guesthouse In Zuthulphuk	01<br />
Hilsa	Hotel In Hilsa Or Similar	01<br />
Kathmandu	Hotel Shankar / Park Village Or Similar	01Any Air fare/ train fare / bus fare, unless specified.<br />
Airfares from Home - Kathmandu - Home.<br />
Any meals / en route meals unless specified.<br />
Any transport to Kathmandu / from Kathmandu. Your tour price starts Ex Kathmandu.<br />
Nepal entry and re-entry visa fees for non-resident Indians.<br />
Alcoholic and Non - Alcoholic beverages and personal nature cost.<br />
Photography charges and Telephone calls.<br />
All beverages during the trip.<br />
Stick and a water bottle.<br />
Travel Insurance of clients and evacuation cost.<br />
Personal horse riding charges during Kailash Parikrama.<br />
Domestic excess baggage charges and airport taxes.<br />
Tips for supporting staff.<br />
Any items and services not mentioned in 'Cost Includes'.<br />
Extra rooms bills due to flight delayes due to weather conditions.<br />
Visa splitting charge and extra transportation cost, if returning early from Tibet.<br />
Any additional cost due to natural calamities and unforeseen circumstances.<br />
4.35% Govt. Service Tax.25-0530-09<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 Kathmandu
								</p>
								<p class="aj">Welcome to your 'Kailash Manasarovar Yatra - By Helicopter' tour! On arrival at Airport in Kathmandu, post customs and immigration, you will be transferred to your hotel. <br />
The rest of the day is at leisure for leisure activities. <br />
Overnight in Kathmandu</p>					
									<p><b>Meals : </b> (Lunch, 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 2:</b> On To Nepalgunj
								</p>
								<p class="aj">Early morning, visit the Pashupatinath Temple which is one of the most significant Hindu temples of Lord Shiva in the world, located on the banks of the Bagmati River in the eastern part of Kathmandu. The temple serves as the seat of the national deity, Lord Pashupatinath. The temple is listed in UNESCO World Heritage Sites list. Later, we visit Guheshwori Shaktipith, is one of the revered holy temples in Kathmandu. This temple is dedicated to Adi Shakti. <br />
Thereafter, drive to the airport in Kathmandu to board your flight to Nepalgunj (450 mts).<br />
On arrival at Nepalgunj, proceed to your hotel.<br />
The rest of the evening is at leisure.<br />
Overnight in Nepalgunj.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch, 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> On To Simikot
								</p>
								<p class="aj">This morning, drive to the airport to board your flight to Simikot (2950 mts). <br />
On arrival at Simikot, proceed to your hotel.<br />
Later, visit Shiva Mandir and get acclimatized to high altitude.<br />
The rest of the day is at leisure for leisure activities. <br />
Overnight in Simikot.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch, 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> On To Hilsa By Helicopter* On To Purang
								</p>
								<p class="aj">This morning, board your helicopter from Simikot for a 30 minute flight to Hilsa.<br />
Arrive Hilsa and drive for 1 hour to reach Purang (3750 mts).<br />
The rest of the evening is at leisure.<br />
Overnight in Purang</p>					
									<p><b>Meals : </b> (Breakfast, Lunch, 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> On To Mansarovar
								</p>
								<p class="aj">Drive to Mansarovar (90 kms / approx. 3 hr drive) to get your first view of the holy Mt. Kailash and Mansarovar. Take a dip and offer prayers in the holy Mansarovar lake.<br />
Overnight in the Mansarovar.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch, 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 6:</b> On To Darchen* Trek To Asthapad
								</p>
								<p class="aj">Early in the Morning Puja at the lake and holy Dip.<br />
Drive to Darchen (4620 mts / 2 hours drive) and then trek to Asthapad.<br />
Overnight in Darchen.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch, 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 7:</b> On To Yamadwar* Trek To Diraphuk
								</p>
								<p class="aj">Drive to Yamadwar (30 minutes drive) and then trek to Kailash Parikrama starting point and trek to Diraphuk. (4750m / walk 5-6 Hours).<br />
Overnight in Diraphuk.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch, 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 8:</b> On To Zuthulphuk
								</p>
								<p class="aj">Today's trek is amongst the most difficult day of the yatra including a steep climb up to Dolma La Pass (5,636 mts), the highest altitude of your parikrama. Stay here for offering prayers and to relax. Slowly descend to your Guesthouse in Zuthulphuk (Trek 10-12 hours).<br />
Overnight in Zuthulphuk.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch, 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 9:</b> On To Purang And To Hilsa
								</p>
								<p class="aj">This morning, after a short trek (2 hrs), drive to Purang and to Hilsa.<br />
Note: Overnight stay would be in Hilsa or Purang depending upon the weather.<br />
The rest of the day is at leisure.<br />
Overnight in Hilsa.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch, 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 10:</b> In Hilsa * Fly To Kathmandu Via Simikot And Nepalgunj
								</p>
								<p class="aj">Early morning, drive to the airport in Hilsa for your flight to Simikot. On arrival in Simikot airport board your flight to Nepalgunj. Once you arrive in Nepalgunj airport take another flight to Kathmandu<br />
On arrival at the airport in Kathmandu, get transferred to your hotel.<br />
Overnight in Kathmandu.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch, Dinner)</p>
								</td>
								</tr>
								</table>					
								</div><div id="show_more_content" style="display:none;">
									<div class="data">
									<table class="w100 formTable bdr0 imgWidth">
									<tr>
									<td class="p10px vat">
									<p class="b large mb5px"><b class="dif">Day 11:</b> Depart Kathmandu* Return Home With Happy Memories
									</p>
									<p class="aj">Today, bid farewell to your 'Kailash Manasarovar Yatra - By Helicopter' as you get transferred to the airport for your onward journey.</p>
									</td>	
									</tr>
									</table>				
									</div>					
							</div>							<p class="mt10px ac"><a class="buttonBig p5px10px dib b" id="more_button" href="javascript:topDestinationToggle('show_more_content','more_button');" >View More &#9660;</a></p>
													<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>Transport</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Any Air fare/ train fare / bus fare, unless specified.</li><li>
Airfares from Home - Kathmandu - Home.</li><li>
Any meals / en route meals unless specified.</li><li>
Any transport to Kathmandu / from Kathmandu. Your tour price starts Ex Kathmandu.</li><li>
Nepal entry and re-entry visa fees for non-resident Indians.</li><li>
Alcoholic and Non - Alcoholic beverages and personal nature cost.</li><li>
Photography charges and Telephone calls.</li><li>
All beverages during the trip.</li><li>
Stick and a water bottle.</li><li>
Travel Insurance of clients and evacuation cost.</li><li>
Personal horse riding charges during Kailash Parikrama.</li><li>
Domestic excess baggage charges and airport taxes.</li><li>
Tips for supporting staff.</li><li>
Any items and services not mentioned in 'Cost Includes'.</li><li>
Extra rooms bills due to flight delayes due to weather conditions.</li><li>
Visa splitting charge and extra transportation cost, if returning early from Tibet.</li><li>
Any additional cost due to natural calamities and unforeseen circumstances.</li><li>
4.35% Govt. Service Tax.</li></ul><br />
												<p class="large b mb5px dif">Specific Departure Dates :</p>Kathmandu<br />
<br />
29 May 2016	04 Jun 2016	10 Jun 2016	22 Jun 2016	28 Jun 2016<br />
04 Jul 2016	10 Jul 2016	16 Jul 2016	14 Aug 2016	20 Aug 2016<br />
26 Aug 2016	01 Sep 2016	06 Sep 2016	12 Sep 2016	18 Sep 2016<br />
24 Sep 2016	30 Sep 2016<br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>~^#^~~^#^~<table border="0" cellpadding="3" cellspacing="0" style="text-align: justify; line-height: normal; font-family: Arial, Helvetica, sans-serif; color: rgb(64,64,64); font-size: 11px" width="100%">
	<tbody>
		<tr class="content_blacknormal11justify">
			<td><strong>DEFINITIONS</strong><br />
			In the terms and conditions set out in this document, the following terms shall, unless contrary to the context, have the meaning specified.<br />
			&nbsp;
			<ul style="margin: 0px; padding-left: 0px; padding-right: 0px">
				<li>&quot;You&quot; means the person / s in whose name and / or whose behalf the Booking is made. Alternatively, the reference may be made in the third person as &quot;Tour Participant&quot;/ &quot;They&quot; / &quot;Client&quot; / &quot;Them&quot; / &quot;His&quot; / &quot;Her&quot;.</li>
				<li>&quot;We&quot;/ &quot;Us&quot;/ &quot;Company&quot; means Cox &amp; Kings Limited.</li>
				<li>&quot;Infant&quot; / &quot;Child&quot; mean respectively a person below the age of two years and a person more than the age of two and below the age of twelve years.</li>
				<li>&quot;Contractor&quot; / &quot;Supplier&quot; means supplier of any infrastructural facility and shall include hotel managements, airlines, caterers, restaurants, places of entertainment like theme parks, museums, art galleries etc shipping company, railway, ferry, cruise, coach who are to provide the services to the Client.</li>
				<li>&quot;Tour Cost&quot; means the tour cost mentioned in the Price Grid / brochures / online and other payments such as taxes, surcharges etc payable by the Client to the Company</li>
				<li>&quot;Brochure&quot; means printed brochure, Website, itinerary, leaflets, booklet, Price Grid.</li>
				<li>&quot;Website&quot; means www.coxandkings.com</li>
				<li>&quot;Web pages&quot; means pages on the Website www. coxandkings.com</li>
				<li>&quot;Cancellation Policy&quot; means and includes all the Cancellation Charges levied by the company from time to time, third party Cancellation Charges etc. as more particularly described hereinbelow or any other documents.</li>
				<li>&quot;VISA&quot; means a Certificate issued or a stamp marked (on the applicant&#39;s passport) by the immigration authorities of a country to indicate that the applicant&#39;s credentials have been verified and he or she has been granted permission to enter the country for a temporary stay within a specified period. (Note: The Company does not have any role to play for issuance/ rejection of Visa other than being a facilitator).</li>
				<li>&quot;Permit&quot; means an official document given by authorized department for entry into any place or destination. (Note: The Company does not have any role to play for issuance / denial of Permit other than being a facilitator).</li>
				<li>&quot;Permit / Visa Cancellation Policy&quot; means and includes all the cancellation charges levied by Consulate / statutory authorities and which interalia includes permit / visa fees and any supplementary charges such as permit / visa facilitation charges, courier fees, SMS charges, urgent fees charged by the Consulate / statutory authorities in addition to the administrative fees charged by the Company.</li>
				<li>&quot;Jurisdiction&quot; means the geographical area over which a court or government body has the power and right to exercise authority. Parties hereto agree to confer exclusive Jurisdiction to Mumbai Courts / Forums.</li>
				<li>&quot;Terms and Conditions&quot; means these terms and conditions and includes the How to Book Rules, Booking Form, Web Pages, Brochure, Price Grid, Itinerary, Promotion Booklet and other documents as may be notified from time to time&quot;<br />
				<br />
				<strong>BROCHURE / WEBSITE INFORMATION DISCLAIMERS</strong><br />
				We take reasonable care in preparing the brochure, price grid, web pages and other documents and in describing the services therein. However, we are not responsible / liable for any typographical / printing errors. Furthermore, brochures may be printed several months in advance and the content may not always be fully updated. We therefore ask you to confirm the current information by contacting us.<br />
				<br />
				Please note that the itinerary may have changed. The products and services displayed may have changed. The photos of meals / sightseeing are for reference only and may differ from the actual meals / sights. Distance between places and temperatures are approximate and can change depending on travel, road conditions and climatic changes.<br />
				<br />
				We hereby disclaim all warranties and conditions with regard to this information, software, products, services and related graphics, including all implied warranties and fitness for a particular purpose, title and non- infringement.<br />
				&nbsp;</li>
			</ul>
			</td>
		</tr>
		<tr>
			<td align="right"><a href="http://www.coxandkings.com/bharatdeko/bhakti-yatra/kailash_mansarovar_yatra_-_by_helicopter/tourId/3844/#tnctop" style="outline-style: none; outline-color: invert; outline-width: medium; color: rgb(53,53,53); text-decoration: none"><img alt="Top" border="0" src="http://www.coxandkings.com/live/themes/images/inner/top.gif" style="border-bottom: 0px; border-left: 0px; border-top: 0px; border-right: 0px" /></a></td>
		</tr>
		<tr class="content_blacknormal11justify">
			<td><strong>ITINERARY MAY CHANGE AT ANY TIME</strong><br />
			We reserve the right to alter, amend, change or modify the tour package and itineraries before or during the tour. We will make reasonable efforts to notify you promptly of such changes / events sufficiently in advance during booking or prior to departure of the tour. If such changes / events occur during the tour, our tour manager or local representative will inform you of the changes on the spot and we solicit your full co-operation in accepting such circumstantial changes. Therefore, no grievance regarding any itinerary / service change which we are constrained to make, will be entertained from the tour participants during or after the tour.<br />
			<br />
			Such changes may be necessitated due to factors beyond our control such as Force Majeure events, strikes, fairs, festivals, sport events, weather conditions, traffic problems, overbooking of hotels / flights, cancellation / re-routing of flights or railways, closure of / restricted entry at a place of sightseeing. Generally, we try to avoid dates when big Fairs, Exhibitions, Olympics etc. And other events are held in certain cities as hotels are fully booked several years ahead. If you have to travel on such dates, you may have to stay in alternate hotels or hotels in other cities.<br />
			<br />
			Due to airline&#39;s requirements the points of entry and exit in a city / country may change. We may operate more than one coach per departure date and may for convenience reverse the direction or amend the itinerary. Change in itinerary may also be required or necessitated on account of actions, inactions, defaults or condition of tour participants.<br />
			<br />
			We will make reasonable efforts to keep the overall package of services unchanged. However, we shall not be responsible / liable to refund any amount or pay any compensation on account of any change in itinerary.<br />
			<br />
			In case the alternate arrangements made are materially superior as compared to the ones described in the Brochure, we may charge extra for the same at the time of booking or in the course of the tour.<br />
			<br />
			<strong>PROMOTIONS / OFFERS / SCHEMES</strong><br />
			Please note that promotional offers may have different terms and conditions which will be in addition to these terms and conditions and the requirements of the booking amounts, payments, deadlines and mode of payment may be defined in such promotions which will be over and above these terms and conditions.<br />
			<br />
			You will have to adhere to the payment schedule prescribed under such offers, promotions or schemes in order to be eligible to avail benefits under such offers, promotions or schemes. If you fail to make the payment by the due date and / or do not comply with all the terms and conditions of the offer, promotion or scheme, you would not be entitled to receive the benefit under such offer, promotion or scheme.<br />
			<br />
			We shall have the absolute right to withdraw any scheme or discount at any time after such scheme or discount is published without prior intimation.<br />
			<br />
			<strong>GENERAL NOTICE REGARDING BOOKING</strong><br />
			Please read carefully and understand the contents of the Tour Brochure / Itinerary, the &#39;Terms and Conditions&#39;, How to Book Rules, Price Grid and such other documents as may be applicable, as all these will form part of your contract with us once you effect the booking. To effect the booking, we may require you to sign the Booking Form and such other documents as we may deem fit including (without limitation) the &#39;Terms &amp; Conditions&#39;, &#39;How to Book&#39; Rules and &#39;Price Grid&#39; (&#39;collectively Booking Documents&#39;). Upon executing the Booking Documents and on payment of the prescribed non-refundable interest-free booking amount, a binding contract shall come into existence.<br />
			<br />
			We advise you to ensure before making a booking that you have and / or you will be able to provide all the required documents to enable you to travel. Please go through our web site and / or check with our staff to ascertain the required documentation.<br />
			<br />
			<strong>CONDITIONS OF OTHER THIRD PARTY&nbsp;</strong><br />
			OPERATORS<br />
			In the event you are booking through us a tour / travel service of any third party operators, the terms and conditions of such third party operators, including their payment schedule, cancellation, refund etc. shall be applicable to you in addition to these Terms and Conditions.<br />
			<br />
			<strong>HELICOPTER PACKAGES</strong><br />
			In the event that you are booking any product which includes helicopter services such as in case of Amarnath Yatra, Mata Vaishnodevi, Kailash Mansarovar tour etc. the same would be subject to the weather conditions / permissions of the shrine boards/ availability at the time of booking and / or any other statutory requirements. The Client cannot hold the Company responsible / liable for any such happening or non happening of any event which is beyond the control of the Company. If the helicopter service remains unutilized for any reasons whatsoever, including the aforesaid reasons then the Company shall not be responsible / liable for any refunds whatsoever.<br />
			<br />
			<strong>ONLINE BOOKING</strong><br />
			You can purchase our services from our sales outlets, Agents or Franchises. In the alternative, you can register and book your tour / services online through our Website. Our Website provides the facility of making online booking of tours and services. However, we cannot give any guarantee or warranty with respect to the Website booking engine which could malfunction due to various reasons including software or network errors. We have incorporated all modern protection technologies to ensure that information concerning you or your payments is kept secure and confidential.<br />
			<br />
			It is made clear that the online booking shall be effective once you confirm the terms and conditions, as follows. During the course of online booking on our Website, you will have the opportunity to go through our terms and conditions and privacy policy, which are displayed on our Website and which you will need to confirm and accept in the course of booking online. Further, you will also need to send us a hard copy of the said Booking Documents confirming that you have read, understood and accepted the Terms and Conditions and other applicable documents including Brochure and / or, Itinerary and / or Price Grid and / or Promotion Booklet. We would also require a copy of the first two pages and last two pages of your passport which show the date of your passport, place and date of issue and expiry.<br />
			<br />
			The Company reserves the right to decline to register any person / s for any tour or to cancel their registration without assigning any reason and without any compensation.<br />
			&nbsp;</td>
		</tr>
		<tr>
			<td align="right"><a href="http://www.coxandkings.com/bharatdeko/bhakti-yatra/kailash_mansarovar_yatra_-_by_helicopter/tourId/3844/#tnctop" style="outline-style: none; outline-color: invert; outline-width: medium; color: rgb(53,53,53); text-decoration: none"><img alt="Top" border="0" src="http://www.coxandkings.com/live/themes/images/inner/top.gif" style="border-bottom: 0px; border-left: 0px; border-top: 0px; border-right: 0px" /></a></td>
		</tr>
		<tr class="content_blacknormal11justify">
			<td><strong>DOCUMENTATION</strong><br />
			A. For buying foreign exchange component of tour cost for International Travel other than travel to Nepal and Bhutan, following documentation is required:<br />
			<br />
			a. Copy of PAN card, which is mandatorily required.<br />
			b. In case of minor where PAN Card is not available, the PAN Card details of parent / guardian are required.<br />
			c. You will have to provide a declaration in Form 60 in case you do not have PAN Card.<br />
			d. Cheque / Demand draft to be in the name of &quot;Cox &amp; Kings Ltd.&quot;<br />
			e. Physically signed booking form by the traveller.<br />
			f. Physically signed terms and conditions form by the traveller.<br />
			<br />
			B. We would also require the following documents from you, under the Reserve Bank of India KYC Guidelines:<br />
			<br />
			a. Physically signed LRS cum Form A2 by the traveller [Only for international travel]<br />
			b. Signed photocopy of the first 2 pages and last 2 pages of your passport.<br />
			c. Valid Visa issued by the country of visit.<br />
			d. Air tickets.<br />
			e. Address Proof:<br />
			<br />
			<strong>FEATURES</strong><br />
			<strong>TRANSACTIONS WITH INDIVIDUALS</strong><br />
			(Address proof)<br />
			<strong>DOCUMENTS</strong>
			<ul style="margin: 0px; padding-left: 0px; padding-right: 0px">
				<li>(i) Passport, (ii) PAN Card, (iii) Voter&#39;s Identity Card, (iv) Driving License, (v) Job Card issued by NREGA(vi) Aadhar Card</li>
				<li>In case of LOW risk customers, &quot;simplified measures&quot; can be applied which shall be deemed to be &quot;officially valid documents&quot;:</li>
				<li>Identity card with applicant&#39;s photograph issued by central/state government departments, statutory / regulatory authorities, public sector undertakings, scheduled commercial banks and public financial institutions</li>
				<li>Letter issued by a gazette officer with a duly attested photograph of the person</li>
			</ul>
			Where &quot;simplified measures&quot; are applied for verifying for the limited purpose of proof of address, the following additional documents are deemed to be Officially Valid Documents (OVD):<br />
			<br />
			vii) Utility bill which is not more than two months old of any service providers (electricity, telephone, post paid mobile phone, piped gas, water bill)<br />
			viii) Property or municipal tax receipt<br />
			ix) Bank account or Post office savings bank account statement<br />
			x) Pension or family pension payment orders, only if they contain address<br />
			xi) Letter of allotment of accommodation<br />
			<br />
			If the proof of address you are providing is in the name of some other member of your family with whom you are living and are closely related, then you would need to provide us such proof of address as mentioned above along with a declaration from the person named in such proof of address stating that you are a relative and are staying with him / her.<br />
			<br />
			If the document of identity produced has an address which is the same as that declared by the prospective Client, the said document may be accepted as valid proof of both identity and address. If different or if a valid photo ID does not have address, then a separate address proof should be obtained<br />
			<br />
			<strong>ONE / SOME MEMBER(S) MAY SIGN BOOKING DOCUMENTS ON YOUR BEHALF</strong><br />
			In case of one or more but not all tour participants named in the Booking Form sign the Booking Documents, it shall be deemed that the signatories have been duly authorized by all such tour participants to sign on their behalf assuming full responsibility and accordingly it shall be deemed that all such tour participants have signed the booking documents.<br />
			<br />
			<strong>YOUR TRAVEL AGENT CAN SIGN THE BOOKING DOCUMENTS ON YOUR BEHALF</strong><br />
			Where tour participants are booking through a Travel Agent, if such Travel Agent signs the Booking Documents, it shall be deemed that such signature is for and on behalf of all the tour participants named in the Booking Form assuming full responsibility. It shall be deemed and construed that all such tour participants have duly authorized the said Travel Agent to sign the Booking Documents on their behalf.<br />
			<br />
			<strong>CONTRACT SUBJECT TO SIGNATURE AND PAYMENTS</strong><br />
			Please note that there is no contract between the Company and the tour participants until the Booking Documents are signed and received by the Company and the Company has also received the specified non-refundable interest free booking amount. The full payment must be received in accordance with prescribed payment schedule. If not paid in accordance with the payment schedule, the Company reserves the right to cancel the booking with consequent forfeiture of booking amount and apply scale of Cancellation Charges as mentioned in the brochure.<br />
			<br />
			Any payment that you make to your Travel Agent would not constitute payment to the Company until the same is remitted to the account of the Company.<br />
			<br />
			<strong>CANCELLATION / AMENDMENT BY COMPANY</strong><br />
			We reserve our right to amend or cancel the tour booked by you, without assigning any reason. Such amendment or cancellation may be due to circumstances beyond our control. In such cases, we will offer you alternative tour dates / tours or you would have the option of travelling as individual travellers, not as part of the original tours. If the alternative date / tour is not acceptable or you do not wish to travel as individual travellers, we would refund the money paid by you after deducting any costs incurred by us on your behalf including cruise cost, airlines, transport, permits / visa, insurance, etc. within a period of thirty days from the date of amendment or cancellation. However, we would not be responsible or liable to pay any compensation or damages or consequential loss or interest or to refund any other expense incurred by you.<br />
			<br />
			<strong>CANCELLATION OF BOOKING BY YOU</strong><br />
			Should you wish to cancel your booking, you must notify us in writing. Such notification shall be deemed to have been given to us only on the date of the receipt of your letter, since we can act only on receipt. Please state the reason for your cancellation as it may be covered by your insurance policy. Claims must however be made direct to your insurance company.<br />
			<br />
			The following Cancellation Charges for the land and airfare packages shall apply irrespective of the reason for cancellation. You understand and acknowledge that these charges are a genuine pre-estimate of the damages that we will suffer on account of cancellation. You understand that these damages are called liquidated damages in legal language, which are payable without proof of actual damages. You agree not to dispute such deductions or to demand proof of actual damages.<br />
			<br />
			In case of cancellation, the following Cancellation Charges would apply.<br />
			<br />
			<strong>For Land or Airfare Packages (Individual Holidays -FIT):</strong><br />
			&nbsp;
			<div class="responsive-data-tbl">
			<table border="1" cellpadding="3" cellspacing="1" class="grayborder" style="background-color: rgb(204,204,204)" width="100%">
				<tbody>
					<tr class="bg_ececec" style="background: rgb(236,236,236)">
						<td width="50%"><strong>When a cancellation is made</strong></td>
						<td width="50%"><strong>Cancellation charges per person</strong></td>
					</tr>
					<tr class="bg_white" style="background: rgb(255,255,255)">
						<td>Clear 30 working days or more prior to the tour departure date or for non-payment of the balance Tour Cost within the stipulated time frame</td>
						<td>Booking Amount</td>
					</tr>
					<tr class="bg_white" style="background: rgb(255,255,255)">
						<td>Clear 29 to 16 working days prior to the tour departure date.</td>
						<td>25% of the Tour Cost</td>
					</tr>
					<tr class="bg_white" style="background: rgb(255,255,255)">
						<td>Clear 15 to 08 working days prior to the tour departure date</td>
						<td>50% of the Tour Cost</td>
					</tr>
					<tr class="bg_white" style="background: rgb(255,255,255)">
						<td>Less than 07 clear working days prior to the tour departure date</td>
						<td>100% of the Tour Cost</td>
					</tr>
					<tr class="bg_white" style="background: rgb(255,255,255)">
						<td><strong>For Tours with Cruise</strong><br />
						Less than clear 80 - 50 working days (depending on the Cancellation Policy of the particular cruise liner) prior to the tour departure date for the Cruise portion.</td>
						<td>100%</td>
					</tr>
					<tr class="bg_white" style="background: rgb(255,255,255)">
						<td colspan="2"><strong>NOTE:</strong><br />
						In case of third party products, such as cruise holiday, bus and train tickets, 5 Star hotels, services during the trade fair period, festival periods, the rules relating to payment terms, cancellation and the cancellation schedule prescribed by the concerned third party service provider would be applicable and in addition the Company shall have the right to claim service and communication charges of INR 2,000/- per person.<br />
						There will be a service tax of 14.50% presently applicable over and above all mentioned charges. Hence, post deduction of cancellation charges with service tax, balance amount will be refunded.</td>
					</tr>
				</tbody>
			</table>
			</div>
			<br />
			<strong>For Airfare packages (Group holidays):</strong><br />
			&nbsp;
			<div class="responsive-data-tbl">
			<table border="1" cellpadding="3" cellspacing="1" class="grayborder" style="background-color: rgb(204,204,204)" width="100%">
				<tbody>
					<tr class="bg_ececec" style="background: rgb(236,236,236)">
						<td width="50%"><strong>When a cancellation is made</strong></td>
						<td width="50%"><strong>Cancellation charges per person</strong></td>
					</tr>
					<tr class="bg_white" style="background: rgb(255,255,255)">
						<td>Clear 40 working days or more prior to the tour departure date or for non-payment of the balance Tour Cost within the stipulated time frame</td>
						<td>Booking Amount</td>
					</tr>
					<tr class="bg_white" style="background: rgb(255,255,255)">
						<td>Clear 39 to 25 working days prior to the tour departure date.</td>
						<td>50% of the Tour Cost</td>
					</tr>
					<tr class="bg_white" style="background: rgb(255,255,255)">
						<td>Clear 24 to 10 working days prior to the tour departure date.</td>
						<td>75% of the Tour Cost</td>
					</tr>
					<tr class="bg_white" style="background: rgb(255,255,255)">
					</tr>
					<tr class="bg_white" style="background: rgb(255,255,255)">
						<td>Less than 09 clear working days prior to the tour departure date.</td>
						<td>100% of Tour Cost</td>
					</tr>
					<tr class="bg_white" style="background: rgb(255,255,255)">
						<td>Less than clear 80 - 50 working days (depending on the cancellation policy of the particular cruise liner) prior to the date of the departure of the tour for the Cruise portion.</td>
						<td>100%</td>
					</tr>
					<tr class="bg_white" style="background: rgb(255,255,255)">
						<td colspan="2">
						<p style="padding-bottom: 0px; margin: 0px; padding-left: 0px; padding-right: 0px; padding-top: 0px"><strong>NOTE</strong>:<br />
						n case of third party products, such as cruise holiday, bus and train tickets, 5 Star hotels, services during the trade fair period, festival periods, the rules relating to payment terms, cancellation and the cancellation schedule prescribed by the concerned third party service provider would be applicable and in addition the Company shall have the right to claim service and communication charges of Rs.2,000/- per person. There will be a service tax of 14.50% presently applicable over and above all mentioned charges. Hence, post deduction of cancellation charges with service tax, balance amount will be refunded.
						</td>
					</tr>
				</tbody>
			</table>
			</div>
			<br />
			<br />
			It is a clear understanding between the parties that for the purpose of this clause, cancellation can be due to any reason whatsoever including the reason of inability to participate due to, illness, death, court orders, non-availability of travel documents etc.<br />
			<br />
			As per the booking conditions, we are constrained to levy the aforesaid Cancellation Charges in addition to the actual administrative / service expenditure incurred towards travel insurance, retention charges by supplier, permits / visa, if any, etc.<br />
			<br />
			If you wish to cancel your booking, you need to inform us by any of the following methods, provided that such information should be given on a working day within working hours:<br />
			<br />
			1. By fax at 91 22 2270 9161 followed by a written communication to our registered office listed below<br />
			<br />
			OR<br />
			<br />
			2. By email to bdfeedback@coxandkings.com followed by a written communication to our Registered Office listed below<br />
			<br />
			OR<br />
			<br />
			3. In writing on at the Registered Office of the Company:<br />
			<br />
			Cox &amp; Kings Limited,<br />
			Customer Service, Bharat Deko<br />
			Turner Morrison Building,<br />
			16, Bank Street, Fort,<br />
			Mumbai - 400 001, India<br />
			<br />
			If the Booking Documents have been signed by one or more persons for themselves and for others mentioned in the Booking Form, then the communication signed by such signatory / s would be treated as a valid communication with full responsibility / liability for cancellation for all such persons mentioned in the form. Similarly if your Agent seeks cancellation, we will act on the basis that he has been authorized or instructed by you to cancel assuming full responsibility and shall accordingly effect cancellation. Cancellation shall take effect only from the time the written request reaches the Company at its office in Mumbai on working days within office time at the details listed above. However, in the following cases you shall be deemed to have cancelled the tour even if no cancellation notice is issued by you:<br />
			&nbsp;</td>
		</tr>
		<tr>
			<td align="right"><a href="http://www.coxandkings.com/bharatdeko/bhakti-yatra/kailash_mansarovar_yatra_-_by_helicopter/tourId/3844/#tnctop" style="outline-style: none; outline-color: invert; outline-width: medium; color: rgb(53,53,53); text-decoration: none"><img alt="Top" border="0" src="http://www.coxandkings.com/live/themes/images/inner/top.gif" style="border-bottom: 0px; border-left: 0px; border-top: 0px; border-right: 0px" /></a></td>
		</tr>
		<tr class="content_blacknormal11justify">
			<td>i) In case of visa rejection, you would be deemed to have cancelled on the date of intimation of such rejection. Please see our Visa Guidance section for further details.<br />
			ii) If you fail to pay the tour costs in time or if you commit any other default in relation to your booking, we may treat such failure or default as a cancellation of the booking by you. In such case, the Cancellation Charges shall be computed with reference to the date on which we issue you a notice of cancellation;<br />
			iii) If on your failure of payment or other default, no notice of cancellation is issued by us but your payment or default remains outstanding on the date of departure, the booking shall be deemed to have been cancelled by you without any advance notice, inviting the applicable Cancellation Charge.<br />
			<br />
			You expressly agree to abide by the foregoing terms and conditions.<br />
			<br />
			<strong>AMENDMENT OF BOOKING BY YOU</strong><br />
			If you wish to amend or change your booking, you have to communicate your request to us in writing and / or email. Such requests for change or amendment will be accepted subject to availability. Please note that:<br />
			<br />
			1) The amended or changed booking will be regarded as a new booking;<br />
			2) An amendment fee of INR 750/- + service tax as applicable is payable in case of every amendment or change;<br />
			3) In case the amendment is carried out within the cancellation period, then a Cancellation Charge shall apply as if a cancellation was made on the date the request for amendment or change is made. Please note the Cancellation Charges specified in the preceding section. Terms and Conditions shall also apply.<br />
			<br />
			<strong>TRANSFER FROM ONE TOUR TO ANOTHER</strong><br />
			A request in writing for transfer from one tour to another 30 days prior to the departure will be treated as cancellation on that tour and a fresh booking on another. In these cases, a transfer fee of Rs.750/- per person + service tax as applicable will be applicable in addition to the costs for re-processing your documentation including permits / visa / cruise / airlines / bus bookings / insurance, etc. due to the transfer to another tour. In case you transfer within the cancellation period, then the Cancellation Policy will also apply. Terms &amp; Conditions shall apply.<br />
			<br />
			<strong>RATE OF EXCHANGE APPLICABLE TO REFUNDS</strong><br />
			Please note that refunds of foreign exchange component of the tour cost will be based on our buying rate of that date. Every day we i.e. Cox &amp; Kings Limited publish on our web page (http:// www.coxandkings.com/live/products/forex/index. php) and through our sales network, our buying and selling rate for foreign currency applicable for that day. When we receive Indian Rupees from you in relation to a booking, we convert them into the foreign exchange component of the tour cost at our selling rate, then applicable. However, when we refund the foreign exchange component to you in Indian Rupees, we do so at our buying rate applicable on the date of refund and after deductions of bank charges as applicable in cases of bank remittance / telegraphic transfer.<br />
			<br />
			<strong>OUR SCOPE OF SERVICES</strong><br />
			We are travel and holiday organizers only. We inspect and select the services to be provided to you. However, we do not own, operate or control any airline, shipping company, coach or coach company, hotel, transport, restaurant, kitchen caravan or any other facility or provider that is engaged to provide you services during the course of your tour. Therefore, please carefully note that:<br />
			<br />
			1) You will need to adhere to the conditions, rules and regulations of each service provider. For instance, you will need to check the baggage rules of the airline to understand what kind of baggage and how much baggage you can carry. You will need to check the hotel rules to check the timings when meal is served, to ensure that you are available at that time. The Company is not responsible / liable for the consequences if you breach such rules and regulations;<br />
			2) If you cause any injury or damage affecting the service provider, then you may be responsible / liable to the service provider and if the service provider recovers any monies from us for such injury or damages, we shall separately charge you for the same;<br />
			3) We cannot be held responsible / liable for any delay, deficiency, injury, death, loss or damage etc. occasioned due to act or default of such service providers, their employees or agents.<br />
			<br />
			<strong>MEALS</strong><br />
			Please refer to the itinerary in the Brochure / Website for details of the meals which would be served to you on the tour. Unlike an airline, we cannot process a special meal, nor can we guarantee a special diet, nor can we guarantee the seating arrangement in a particular section of the restaurant. We do not assure special meals, or special timings or extra halts for infants, children, or passengers with diabetes, cholesterol, high blood pressure or any other condition. We cannot guarantee quantity of the food as may be provided by the service provider. If you have any such special requirements arising from medical conditions, customs and practices or from the needs of your children or otherwise, it would be advisable to travel on a customized tour and coach tours are not recommended.<br />
			<br />
			We, however, reserve the right to change the meal arrangement, where circumstances compel us to do so. At some places a meal allowance may be paid at our discretion to you to enable you to have a meal of your own choice.<br />
			<br />
			<strong>HOTELS</strong><br />
			The Company selects hotels for your stay at locations, which give comfort and value for money. For various reasons, such as reducing the overall travelling time on the coach for the following day, the hotels may be chosen away from the city centre.<br />
			<br />
			Modern facilities such as attached toilets with showers / bathtubs are provided. We cannot guarantee the availability of adjoining rooms / interconnecting rooms / non-smoking room / rooms on the same floor etc. and are subject to availability. If you seek a change in rooming while on a tour, the same will be subject to availability and you will need to pay any additional charges as may be applicable. The check in and check out times may vary from city to city. Usually, the check-in time is 12:00 noon and check- out by 11:00 a.m. You may have to wait for some time till the rooms are cleared. However, in case the room is required on immediate occupancy / late check out, kindly inform our sales executive to assist on the same at an additional cost.<br />
			<br />
			During trade fairs, sometimes last minute hotel tariffs may vary from their normal / displayed rates for which we shall not be responsible / liable for any variation in the rate displayed by the hotel.&nbsp;<br />
			<br />
			We shall not be held liable / responsible in case the hotel provided is not the same as mentioned on the Website at the time of booking. We reserve the right to change the hotel any time due to any reasons. No refunds or compensation will be provided in case we are not able to provide confirmation of the hotel mentioned on the Website.<br />
			<br />
			Any damage caused to the hotel property by you will have to be paid directly and we would not be liable / responsible for the same.<br />
			&nbsp;</td>
		</tr>
		<tr>
			<td align="right"><a href="http://www.coxandkings.com/bharatdeko/bhakti-yatra/kailash_mansarovar_yatra_-_by_helicopter/tourId/3844/#tnctop" style="outline-style: none; outline-color: invert; outline-width: medium; color: rgb(53,53,53); text-decoration: none"><img alt="Top" border="0" src="http://www.coxandkings.com/live/themes/images/inner/top.gif" style="border-bottom: 0px; border-left: 0px; border-top: 0px; border-right: 0px" /></a></td>
		</tr>
		<tr class="content_blacknormal11justify">
			<td><strong>HOTEL STANDARDS</strong><br />
			Hotel standards vary throughout India. Hotels in India continually try to upgrade their services and there can be ongoing renovation works throughout the year. We will endeavour to obtain rooms as far away from such activity as possible but please bear in mind that hotels run on full capacity during peak season and specific rooms can rarely be pre-booked. Hotels may be booked far off from central place. Please note that basic amenities will depend on the destination and local infrastructure available.<br />
			<br />
			Economy hotels are budget hotels and they may not have any star category classification obtained from the relevant authorities of Government of India. Even 2 star properties approved by the India Tourism, Government of India, can be considered as economy hotels. These hotels may provide very bare basic amenities.<br />
			<br />
			Standard hotels are mainly 3 star category hotels approved by the India Tourism, Government of India. They may also include Heritage hotels, Lodges and Resorts.<br />
			<br />
			Deluxe hotels can be categorized with ratings of 4 star or 5 star approved by the HRACC, India Tourism, Government of India. They may also include Heritage hotels, lodges and resorts.<br />
			<br />
			Heritage hotels are set in old or historic style buildings and are categorized into grand, classic and heritage. If you would like to stay in any of hotels other than those featured in the tour itinerary, or you would like to upgrade the standard of your room, this can be arranged and you will be informed of the difference in price and this would be subject to availability.<br />
			<br />
			Hotels can be booked on the following occupancy basis:<br />
			<br />
			<strong>Single Accommodation</strong><br />
			In case you book on a single occupancy basis, you will have to pay a single room supplement unless another tour participant is willing to share your room. You shall also be responsible / liable to pay the single room supplement if earlier having booked on a shared room basis, you later have to take the room on single occupancy basis since your intended room partner has either dropped out of the tour for any reason or since you and / or your room partner are no longer willing to share a room.<br />
			<br />
			Note that the single room supplement will be charged in all cases where a booking on a shared room basis has to be changed to single room basis including the following:<br />
			&nbsp;
			<ul style="margin: 0px; padding-left: 0px; padding-right: 0px">
				<li>Intended room partner was arranged by you.</li>
				<li>Intended room partner was arranged by us for you.</li>
				<li>No room partner was found available for you.</li>
			</ul>
			<br />
			<strong>Double / Twin Accommodation</strong><br />
			A double room has either a single queen-size bed or two separate beds. If the Client requests for a room with queen-size bed or twin bed, the same would be provided subject to availability as most of the hotel rooms are twin- bedded. In case of non-availability of a room with a queen- sized bed, a twin beddedroom would be given. In case of non-availability of either of them, the booking will be made based on the availability of the hotel.<br />
			<br />
			<strong>Triple Accommodation</strong><br />
			We recommend a maximum of only (3) three persons in one room. Triple rooms are usually no larger than twin rooms and the third bed is often a rollaway bed or cot placed in a twin room. Some hotels do not allow a third occupant. This however is subject to the concerned hotel policy.<br />
			&nbsp;</td>
		</tr>
		<tr>
			<td align="right"><a href="http://www.coxandkings.com/bharatdeko/bhakti-yatra/kailash_mansarovar_yatra_-_by_helicopter/tourId/3844/#tnctop" style="outline-style: none; outline-color: invert; outline-width: medium; color: rgb(53,53,53); text-decoration: none"><img alt="Top" border="0" src="http://www.coxandkings.com/live/themes/images/inner/top.gif" style="border-bottom: 0px; border-left: 0px; border-top: 0px; border-right: 0px" /></a></td>
		</tr>
		<tr class="content_blacknormal11justify">
			<td><strong>Children Accommodation</strong><br />
			A child travelling for whom &#39;without a bed&#39; charge has been paid would not be entitled to a separate bed in the hotel. In case &#39;with bed&#39; charge has been paid for the child and you decide not to avail such facility whilst on the tour, you would not be entitled to any refund. In case you decide to seek an extra bed for the child booked on &#39;without bed&#39; basis on the tour, this will be provided subject to availability and you shall be bound to pay any additional amount charged by the concerned hotel directly.<br />
			<br />
			<strong>PRE / POST TOUR / ADD ON EXTENSION PACKAGES</strong><br />
			Pre / post tour accommodation / add on packages or extensions etc. are available to you at special rates. You must ensure that you request your Travel Agent or your sales officer for the same at the time of booking your tour.<br />
			<br />
			<strong>COACH AND SEATING</strong><br />
			We generally engage air-conditioned / non-airconditioned luxury coaches / cars, but we are not responsible / liable if the air-conditioning equipment malfunctions for any reason. Normally, the air conditioning will not function during hill drives for coaches and cars.<br />
			<br />
			On group tours, you are not allotted seat numbers as a seat rotation system is followed. You must follow the instructions of the Tour Manager in this regard.<br />
			<br />
			The coach / car drivers are bound by restrictions concerning maximum driving hours per day and per week and the itineraries are planned having regard to the same. It is therefore essential that the itineraries, schedules and timings are strictly adhered to by you so as to ensure that all the services can be duly provided. If you or any of your co-passengers miss any service due to unpunctuality, we shall not be responsible / liable to refund any amount. Further, we shall not be responsible / liable to refund any amount or pay any compensation for any change in itinerary or for missing any service due to the unpunctuality or actions of your co-passengers or for any delays due to any reasons.<br />
			<br />
			Please note that smoking, consumption of alcoholic beverages and snacks is strictly prohibited on coaches/ cars. Please keep the coaches / cars clean to avoid discomfort to yourself and other tour participants.<br />
			<br />
			Please take care not to leave behind any property in the coach / car while disembarking. The Company would not be responsible or liable in case of theft / loss of such property under any circumstances.<br />
			<br />
			<strong>PORTERAGE</strong><br />
			Please note that porterage is not included in the tour price.<br />
			<br />
			<strong>BAGGAGE ON COACH</strong><br />
			It is often difficult to get porters to assist as hotels may or may not provide this service and it is therefore advisable to use bags with wheels. Coaches / cars have limited space for luggage and hence we permit only one suitcase and one handbag per person in the coach for group tours. The suitcase should be of a size of 158 cms. (width + length + height).<br />
			<br />
			<strong>BAGGAGE ON AIRLINE</strong><br />
			If you carry more than the permitted luggage weight then, in such case you may have to pay extra charges for luggage to the airline directly and the Company shall not be responsible / liable in this regard. You are requested to please refer to the baggage rules of the individual airlines as the same gets updated from time to time. Also, we are not responsible / liable for any loss or damage to baggage while it is in the custody of the airline.<br />
			<br />
			Please note that every airline has a different set of rules and regulations regarding the weight restrictions, the kind of luggage and the number of baggage and furthermore, airlines keep changing the rules quite frequently. Hence, you are requested to please check the updated baggage rules of the individual airlines, with whom the ticket is booked.<br />
			<br />
			We are not responsible / liable, in any manner, if you are unable to carry any baggage or if you have to pay any extra- charges due to restrictions imposed by the airline. You shall be responsible / liable to pay all such charges directly to the airline. Also, we are not responsible / liable for any loss or damage to baggage while it is in the custody of the airline.<br />
			<br />
			<strong>AIRLINES</strong><br />
			We shall in no circumstances whatsoever be responsible / liable to you or any person travelling with you, for loss of baggage by the airline, failure to provide meal of your choice by the airline, denied boarding or down-gradation due to overbooking or any other reason, failure on the part of the airline to accommodate you despite having confirmed tickets, quality or quantity of meals offered by the airlines, flight delay or rescheduling, flight cancellation, changes of flight schedule or routing, change of airline mentioned at the time of booking. In these circumstances, we will not be responsible / liable for the injury, loss or inconvenience suffered by you but you will be free to pursue your remedies against the concerned airline.<br />
			<br />
			If you are travelling to a SAARC country, it is absolutely necessary to have your return air seats to India confirmed prior to your departure from India.<br />
			&nbsp;</td>
		</tr>
		<tr>
			<td align="right"><a href="http://www.coxandkings.com/bharatdeko/bhakti-yatra/kailash_mansarovar_yatra_-_by_helicopter/tourId/3844/#tnctop" style="outline-style: none; outline-color: invert; outline-width: medium; color: rgb(53,53,53); text-decoration: none"><img alt="Top" border="0" src="http://www.coxandkings.com/live/themes/images/inner/top.gif" style="border-bottom: 0px; border-left: 0px; border-top: 0px; border-right: 0px" /></a></td>
		</tr>
		<tr class="content_blacknormal11justify">
			<td><strong>AIRLINE, AIRPORT OR WEATHER DELAYS</strong><br />
			The Company is not liable / responsible for any additional expenses or loss that may arise from government regulation or order affecting the aircraft, strikes and labour disputes causing cessation, slowdown or interruption of work, meteorological conditions, security risks, or any other causes that are beyond the Company&#39;s control but which may affect concerned airline&#39;s ability to operate flights on schedule. The Company will not reimburse any additional expenses incurred by you as a result of such events or delays. The Company will not refund any unused portion of air tickets purchased or unused services in the event of such delays or due to any reasons beyond its direct control.<br />
			<br />
			<strong>AIRLINE DATE CHANGE BEFORE DEPARTURE</strong><br />
			If are you travelling on an air ticket for a group tour issued by Cox &amp; Kings and wish to travel in advance or return at a later date after the tour ends, then you must pay the applicable difference between the group airfare within the package holiday tour cost and the individual market airfare for the changed sector. The same will be quoted by us to you on your request. Over and above this you will also be required to pay an &#39;Airline Seat Rebooking and Reservation Fee&#39; of INR 2,750/- or as applicable per person per sector, per change depending on the airline (subject to availability of seats and ticket validity). Please note that you will not be able to avail of the group transfers and accordingly you will have to make your own way to meet up with the group on arrival and/ or to your next destination when your tour ends. We shall not be responsible / liable to refund any amount to you in this regard. Terms &amp; Conditions shall apply.<br />
			<br />
			<strong>AIRLINE CONFIRMATION AND RECONFIRMATION</strong><br />
			Though you may receive a confirmed air ticket for a particular sector, airlines often overbook seats, due to which the airline may offload even confirmed passengers and may accommodate them on a subsequent flight. We will not be responsible / liable for any such offloading nor for any consequence of such offloading including delay, inconvenience or loss of tour services. As you are booked on a group fare ticket, please note that seat allotment will be made only when you physically report at the airport check in counter. You are advised to report at the airport check in counter at least 3 to 4 hours for international flight and 2 to 3 for domestic flight prior to the departure time. Seat allocation is a matter of airlines discretion and availability of seats is not in the control of the Company. Hence the Company shall not be held responsible / liable if you do not get seats together or do not get your preferred seats. Please note that in case you are returning on a later date after the tour ends, the responsibility / liability to re- confirm air tickets 72 hours prior to the departure would be solely yours.<br />
			<br />
			<strong>YOU ARE RESPONSIBLE FOR YOUR DOCUMENTS AND POSSESSIONS</strong><br />
			You will have to take the risk and responsibility / liability of all your baggage, belongings, currency, valuables, documents and personal effects (collectively &#39;baggage&#39;) at all times during the tour, whether during travel on the airline or during your stay in hotel or during your travel in coaches, while on excursions or otherwise.<br />
			<br />
			If you forget to carry or if you lose essential travel documents such as permits, passport, ID, visa, tickets etc., you may be compelled to curtail the tour and you may have to incur extra expenses, for which you alone shall be responsible / liable.<br />
			<br />
			In view of what is stated above, please carefully note that:<br />
			<br />
			1) We shall not be responsible or liable for any loss or damage in respect of your baggage etc. or their contents whether due to theft, accident, negligence or otherwise;<br />
			2) We shall not be responsible / liable for any cancellation or curtailment of your tour compelled by any such loss of baggage etc. and we shall pay no compensation or refund to you;<br />
			<br />
			It is advisable that you do not carry valuables on the tour. However, if you carry any valuables, we recommend that you use all available facilities to keep them secure during your tour. In this regard, some hotels provide Safe Deposit Lockers (which may be charged separately). In case of airlines, we recommend that you declare your valuables to the airline at the time of check-in and pay an additional charge, as may be stipulated by the airline, to make the airline responsible for valuables. Without such declaration, airlines can invoke limitation of liability protections provided under international conventions and laws.<br />
			<br />
			If your baggage is lost or misplaced at any time during the course of your tour, it is your responsibility / liability to take all appropriate actions to file complaints with the concerned authorities, including police, airline office etc. In the case of group travel, the tour manager is responsible for the whole group of tour participants, he may not be in a position to escort you to lodge a complaint with the authorities, as it could compromise the convenience and time of the group.<br />
			<br />
			Furthermore, tour managers / assistants / escorts are assisting the tourists throughout the tour and are not responsible for tourists&#39; baggage or any kind of personal belongings. On the entire tour, the tourists have to be responsible / liable and carry the baggage on their own. Instructions as well as information of the tour are to be followed in the group tours and the tour manager/ Company is not responsible / liable for any instructions overruled by the tourists and / or its consequences.<br />
			&nbsp;</td>
		</tr>
		<tr>
			<td align="right"><a href="http://www.coxandkings.com/bharatdeko/bhakti-yatra/kailash_mansarovar_yatra_-_by_helicopter/tourId/3844/#tnctop" style="outline-style: none; outline-color: invert; outline-width: medium; color: rgb(53,53,53); text-decoration: none"><img alt="Top" border="0" src="http://www.coxandkings.com/live/themes/images/inner/top.gif" style="border-bottom: 0px; border-left: 0px; border-top: 0px; border-right: 0px" /></a></td>
		</tr>
		<tr class="content_blacknormal11justify">
			<td><strong>TRAVEL DOCUMENTS, VISA AND CLEARANCES</strong><br />
			It shall be solely your responsibility / liability to hold valid and genuine travel documents and statutory clearances, to enable you to travel on the tour such as passports / ID / permits / visa / cruise / train / bus / confirmed tickets / insurance or any other statutory certificates including immigration clearances, etc. In any case, your Passport must be valid for at least six months or as applicable subsequent to the scheduled date of return of the Holiday. It is the responsibility / liability of the Clients to furnish all documents required by the Company for application of visa etc. The Client acknowledges that the Company is merely a facilitator for providing visa guidance services. In the event the application for the visa made by any Client or the Company on behalf of the Client is rejected by the concerned Embassy or Authorities due to inadequate documents furnished by the applicant or due to any other reason whatsoever, the Company shall not be responsible / liable for the same. The visa fee includes the actual visa charge, cost of processing fees, professional charges, and overheads. All costs, charges in respect of the said application for the visa shall be borne by the Client and the non-refundable amount paid by the Client shall be forfeited and no claim whatsoever shall be made for the same. Granting or rejecting visa and immigration clearance is the sole prerogative of the concerned sovereign governments and the Company is only a facilitator, the Company shall neither be responsible in case of non- granting of such documents nor liable for any delay, denial or other related act / omission or for any loss, expense, damage or cost resulting there from.<br />
			<br />
			In case of cancellation of the tour by the Client due to non-availability of travel documents, the situation would not change only by virtue of the Client having applied for such documents through the Company. Even if the visa is rejected, the stipulated fees of the Company shall be payable by the Client. There will be no refund, if the Client, or any member of his party, is unable to travel due to the said reasons. In such cases, Cancellation Charges as applicable by the Company will apply and the decision of the Company will be final and binding upon you. Under the circumstances, you agree not to proceed legally against us unless there is a manifest error from our end. In the event that a Client is unable to travel on the Holiday date originally booked by him / her, due to rejection of visa by the concerned Embassy, the said Client shall have the option to postpone his / her -tour to any other future date or choose any other holiday destination subject to Cancellation Charges of the previous tour. However, if the Client books and pays within the cancellation period and is unable to travel due to any reason whatsoever including non-availability of visa or any travel documents, the Cancellation Policy will apply.<br />
			<br />
			The Company would not be responsible / liable in any manner whatsoever for any clerical error made by the concerned Embassy / Consulate regarding name, attachment of wrong photograph, duration and type of visa (single / multiple entry) or passport number.<br />
			<br />
			We always use services of reputed courier companies for the purpose of transmission of passports to the Embassies / Consulates and to our Clients in various cities. We would not be responsible for any loss or damage whether direct, incidental or consequential caused due to transmission delays or loss of passport. The documents forwarded by you for visa purpose are sent by us to the concerned Embassy / Consulate by third parties and hence we would not be responsible / liable for loss of your documents. We would however, make best attempts to trace your documents or assist you in obtaining alternative / certified copies of the lost documents.<br />
			<br />
			<strong>HEALTH</strong><br />
			Please note that your health is entirely your risk and responsibility. Our tours are suitable for persons of reasonable fitness. They may not suit persons who are medically infirm or who have special needs or requirements whether due to age, medical conditions or otherwise.<br />
			<br />
			It shall be your duty to inform us in writing in case you have any medical condition that may affect your ability to fully enjoy our tour arrangements or where the interests of other tour participants may be adversely affected by such condition. Under such conditions we may decline to accept you or continue you on that tour.<br />
			<br />
			We reserve the right (without obligation) to ask you to undergo medical tests and to provide written certification of your medical fitness before departure or at any time during the tour and if you fail to undergo such tests or fail to provide such certificates, we may decline to accept you or to continue you on the tour. Our actions in this regard may be guided not only by concerns for your health but also the convenience and health of the other tour participants.<br />
			<br />
			However, it is not our obligation to check your medical condition and if you suffer any injury or aggravation on the tour or if you are unable to enjoy / complete the whole or any part of the tour due to your medical conditions, we shall not be responsible / liable to compensate you nor to refund any amount to you nor to pay your medical expenses. If any adventure sports are included in the tour package, you shall avail of the same at your own risk having regard to your medical condition. We shall not be liable for any death, injury or other loss due to your participation in such adventure sports and any release form that you may be required to sign for such person / service provider / club / association / organization / hobbyist / institution will be binding.<br />
			<br />
			In this regard, please note that service providers such as airlines may decline to accept you on medical grounds. Please carefully read and understand the rules and regulations of the service providers, because we shall not be responsible / liable for the consequences that you may suffer. To some extent, your losses on account of cancellation or curtailment attributable to hospitalization as also your expenses of hospitalization may be covered by insurance.<br />
			&nbsp;</td>
		</tr>
		<tr>
			<td align="right"><a href="http://www.coxandkings.com/bharatdeko/bhakti-yatra/kailash_mansarovar_yatra_-_by_helicopter/tourId/3844/#tnctop" style="outline-style: none; outline-color: invert; outline-width: medium; color: rgb(53,53,53); text-decoration: none"><img alt="Top" border="0" src="http://www.coxandkings.com/live/themes/images/inner/top.gif" style="border-bottom: 0px; border-left: 0px; border-top: 0px; border-right: 0px" /></a></td>
		</tr>
		<tr class="content_blacknormal11justify">
			<td><strong>TRAWELLTAG COVER-MORE ASSISTANCE AND INSURANCE</strong><br />
			Your Travel insurance which is underwritten by United India Insurance Co. Ltd. is an add-on benefit provided by TrawellTag Cover-More along with its assistance services and ancillary products, which is included in our tour package (excluding group tours, third party products and SAARC Countries) that entitles you to travel insurance cover during the duration of the tour. An additional charge is payable in case you wish to extend the duration of your tour. The cover is provided for all the passengers only up to 80 years of age in case of domestic travel. All passengers travelling overseas and above the age of 80 years should undergo the required medical tests post which the insurance company will issue travel insurance at an extra premium paid by the passenger. We shall not be liable for any consequences arising due to a pre-existing medical condition on participation in adventure sports even if you have opted for an additional adventure sports cover. It must be noted that pre-existing diseases are not covered under this insurance policy.<br />
			<br />
			Please take note that, in case of death of the tourist (s) all the arrangements for transportation of the dead body including procuring the death certificate, post - mortem, re - patriation of dead body and all personal effects / property and insurance claims etc. shall be made by accompanying relative and / or accompanying known acquaintances of the deceased. Company shall not be responsible for extending any help for the same. The entire expenses shall be borne by the accompanying relative / or accompanying known acquaintances of the tourist. The Company or any tour leader shall not be responsible for the same. In case any of the relatives wants to visit the country where the tourist has expired, all the necessary arrangements shall be made by the said relative only at his / her cost.<br />
			<br />
			Please note that you would have a direct contractual relation with the insurance company and we are not in any manner responsible for the decisions taken by the insurance company. You shall directly submit claims to your insurance company. The insurance company shall directly pay the settlement amounts to you and any dispute in regard to rejection of claim or adequacy of settlement amount shall be settled by you directly with the insurance company. For details on risk factors, terms and conditions, please read the policy terms and conditions carefully.<br />
			<br />
			<strong>Notes</strong><br />
			Cox &amp; Kings will provide Travel Insurance for passengers travelling to Kailash Mansarovar Yatra subject to approval by the insurance company and for an additional cost. For group tours and all third party products, insurance cost is not included in the tour cost. b) It must be noted that all Non - Resident Indians / Foreign Nationals need to buy insurance on their own for the specified tour and time period as per the regulatory guidelines. Cox &amp; Kings will not be liable for purchasing insurance for Non - Resident Indians / Foreign Nationals.<br />
			<br />
			<strong>NRIs &amp; FOREIGN NATIONALS</strong><br />
			Non-resident Indians / foreigners can pay the Tour Cost in any convertible foreign currency received through normal banking channels or by debiting their NRE / FCNR accounts or against INR payment representing proceeds of foreign currency surrendered by them during their visit to India, duly supported by encashment certificates as per RBI rules. Foreign nationals residing in India can make payment in Indian Rupees against proof of residency and a photocopy of the same.<br />
			&nbsp;</td>
		</tr>
		<tr>
			<td align="right"><a href="http://www.coxandkings.com/bharatdeko/bhakti-yatra/kailash_mansarovar_yatra_-_by_helicopter/tourId/3844/#tnctop" style="outline-style: none; outline-color: invert; outline-width: medium; color: rgb(53,53,53); text-decoration: none"><img alt="Top" border="0" src="http://www.coxandkings.com/live/themes/images/inner/top.gif" style="border-bottom: 0px; border-left: 0px; border-top: 0px; border-right: 0px" /></a></td>
		</tr>
		<tr class="content_blacknormal11justify">
			<td><strong>LIABILITIES</strong><br />
			Please go through the Terms and Conditions carefully to understand your rights, responsibilities, risks and the extent of our liabilities.<br />
			<br />
			As earlier stated, being tour organizers, we will not be responsible / liable to you for any loss, injury or damage in respect of life, limb or property, sickness, delay, discomfort, anxiety, service denial, service deficiency, additional expenses incurred by you or for any direct, indirect, consequential loss and / or damage of any kind suffered by you howsoever caused arising out of any act, omission, default of any contractor / supplier or of any servant or agent employed by the contractor / supplier or of any third person who may be engaged or concerned in the provision of accommodation, meals, transportation, entertainment, refreshment or any other service etc. comprising the tour package. In view of this, please note that we shall have no liability in the following circumstances (amongst others):<br />
			&nbsp;
			<ul style="margin: 0px; padding-left: 0px; padding-right: 0px">
				<li>Failure on the part of airline / bus/ cruise/ train to accommodate passengers (despite having confirmed tickets) or cancellation, change of route, delay of flights / bus/ cruise/ train.</li>
				<li>Overbooking of seats / rooms by the airline / hotel.</li>
				<li>Loss of / delay of baggage by airline / coach / cruise/ train / hotel.</li>
				<li>Any death, personal injury, sickness, accident, loss, delay, discomfort, increased expenses, consequential loss and / or damage or any kind of theft howsoever / wherever / whenever caused;</li>
				<li>Rudeness or unprofessional						
    	<p class="h dif xlarge b mb5px">Package Cost</p>
    	<div class="otherDetails aj">Rates Valid for Kailash Mansarovar Yatra - By Helicopter<br>
Show All  |  Close All<br>
Ex - Kathmandu    Valid From - 01 May, 2016    Valid To - 30 September, 2016<br>
<br>
Standard<br>
<br>
Per Person on Twin Sharing Basis	170999.00<br>
On Triple Sharing	170999.00<br>
On Single Occupancy	176999.00</div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Kailash Mansarovar Yatra - By Helicopter Tour - 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="60811"/>
						</form>
						</div>
						
						";i:1;s:75:"Book Kailash Mansarovar Yatra - By Helicopter Tour - 111 Days Tour Packages";i:2;s:152:"book kailash mansarovar yatra - by helicopter tour - 111 days tour packages, religious & pilgrimage tour packages, kathmandu, tibet, banke tour packages";i:3;s:196:"Grand India Tours & Travels offers Kailash Mansarovar Yatra - By Helicopter Tour - 111 Days tour package, budget Religious & Pilgrimage tour packages for Kathmandu, Tibet, Banke at exciting price.";i:4;s:3955:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Kathmandu, Tibet, Banke"        
		                 },
		      "description": "he world looks to India for answers to spiritual questions. Here great masters have established temples of learning that attracts seekers from all over. The walls of these holy places reverberate with the tinkling sounds of the bells and resonant chants fill the air.
HIGHLIGHTS-
Visit Pashupatinath Temple.
Explore the holy Mt. Kailash and Mansarovar.

* Ex - Kathmandu
Kathmandu, Nepalgunj, Simikot, Manasarovar, Diraphuk, Zuthulphuk, Purang & Hilsa

Pilgrimage
In the northern part, there is a mighty mountain by the name Himalaya,

Note.
Arrival into and departure from Kathmandu Airport would be on your own arrangements.
Do carry comfortable walking shoes.
As per new rules, booking should be done 1 month in advance.
Fullmoon Dates 2016 at Mansarovar/Kailash: May 21*, June 20*, July 19*, August 18*, September 16*.
It is mandatory to carry a valid passport - validity 6 months before travel date and two copies of pp size photograph.
Please contact our sales staff to give you best flight deals.
The hotel confirmed will be as per the brochure or an alternate hotel of similar category.
Itinerary is subject to change due to unavoidable circumstances and the extra cost incurred has to be paid by the clients.
On Day 01, lunch will be served to guests checking in at the hotel by 1400 hours.
Double sharing hotel in Nepalgunj and 3or 4pax in Simikot and Tibet.
All sightseeing is subject to weather, political conditions in the destination.
After the Mansarovar to Kailash; all the private vehicles are not allowed; So Yatri will be escorted by the ECO- buses only.
Single occupancy will be applicable for 02 nights stay in Kathmandu only. Stay at rest of the places will be on twin / triple sharing.
It is mandatory to carry a valid photo identity card (Passport / Driving Licence / Voter ID card).
Transport from Kailash to Mansarovar will be by Eco Deluxe Bus, provided by the Tibet Tourism as no private vehicles are allowed in that particular region.
'PL' denotes Packed Lunch.
'L-LR' denotes Lunch at local restaurant.
'EL' denotes en route Lunch.Standard

City	Hotel	No of Nights
Kathmandu	Hotel Shankar / Park Village Or Similar	01
Nepalgunj	Hotel Siddhartha Or Similar	01
Simikot	Sun Valley Resort Or Similar	01
Purang	Purang Hotel Or Similar	01
Mansarovar	Mansarovar Guesthouse Or Similar	01
Darchen	Hotel In Darchen Or Similar	01
Diraphuk	Guest House In Dirapuk	01
Zuthulphuk	Guesthouse In Zuthulphuk	01
Hilsa	Hotel In Hilsa Or Similar	01
Kathmandu	Hotel Shankar / Park Village Or Similar	01Any Air fare/ train fare / bus fare, unless specified.
Airfares from Home - Kathmandu - Home.
Any meals / en route meals unless specified.
Any transport to Kathmandu / from Kathmandu. Your tour price starts Ex Kathmandu.
Nepal entry and re-entry visa fees for non-resident Indians.
Alcoholic and Non - Alcoholic beverages and personal nature cost.
Photography charges and Telephone calls.
All beverages during the trip.
Stick and a water bottle.
Travel Insurance of clients and evacuation cost.
Personal horse riding charges during Kailash Parikrama.
Domestic excess baggage charges and airport taxes.
Tips for supporting staff.
Any items and services not mentioned in 'Cost Includes'.
Extra rooms bills due to flight delayes due to weather conditions.
Visa splitting charge and extra transportation cost, if returning early from Tibet.
Any additional cost due to natural calamities and unforeseen circumstances.
4.35% Govt. Service Tax.25-0530-09",
		      "name": "Kailash Mansarovar Yatra - By Helicopter Tour",
		      "telephone": "+91-9415285186"
		    }
		    </script>
			";i:5;N;}