a:6:{i:0;s:20435:"				<div class="h1"><h1>Darjeeling Tour 04 nights/05 days</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.chaturveditravels.com/" title="Home">Home</a> 
				
								
				<b class="ffv p2px">&rsaquo;</b>Darjeeling Tour 04 nights/05 days</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">CTT/55 04 NIGHTS / 0</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						4 Nights / 5 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Darjeeling, Bagdogra</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 14700 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="Darjeeling Tour 04 nights/05 days - 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="28199"/>
						</form>
						</p>
						</td>
						</tr>
											</table>
					</td>
										</tr>
					</table>
					</div>
					<br />
					
					Government Service Tax As Applicable (As On Date 01/04/2012 It Is 3.09%)<br />
Cost For Supplementary Service, Optional Tours, Up-Gradation Charges, Guide, Sightseeing Entrance Fees. <br />
Cost For Airfare, Train Fare, Insurance Premiums, Rafting Charges. <br />
Cost For Service Provided On A Personal Request. <br />
Cost For Personal Expenses Such As Laundry, Bottled Water, Soft Drinks, Incidentals, Porter Charges, Tips Etc. <br />
Cost For Any Other Service Not Mentioned Under The Cost Includes Head. <br />
Difference In Cost Arising Due To Change In Taxes By The Government Which Will Have To Be Collected Directly On Arrival. <br />
Difference In Cost Arising Due To Change In Fuel Price (Calculation Based On Petrol Inr 78 Per Liter & Diesel Inr 58 Per Liter) <br />
Difference In Cost Arising Due To Extra Usage Of Vehicle, Other Than Scheduled & Mentioned In The Itinerary. <br />
Difference In Cost Arising Due To Mishaps, Political Unrest, Natural Calamities Like - Landslides, Road Blockage, Etc. In Such Case Extra Will Have To Be Paid On The Spot By The Guest Directly. <br />
Supplement For Oneside Pickup Or Drop To/From Darjeeling/Kalimpong/Gangtok Will Be As Follows-<br />
Pick Up Or Drop From Drj / Gtk / Kpg	Nac Indica / Tata Sumo	Luxury Vehicle (Scorpio /Bolero/ Xylo)<br />
To Phuntsholing (Bhutan Border)	Inr 3000.00 Per Vehicle	Inr 4500.00 Per Vehicle<br />
To  Bhadrapur (Nepali Airport)	Inr 3000.00 Per Vehicle	Inr 4500.00 Per Vehicle<br />
The Following Points Are To Be Noted For Child Rate<br />
Children Above 10+ Years Will Be Charged 100% As Per Adult Rate (Epsr)<br />
Children Of 5+ To 10 Sharing Parent’s Room Will Be Charged As Per Cwb Or Cnb<br />
Children Below 5 Years Complimentary<br />
(Hotels Are Very Strict With The Child Policy. Please Carry The Age Proof So That It Can Be Produced When Asked For)<br />
For Further Information Please Click On The Below<br />
Important Note On Travellers Travelling To Sikkim & Darjeeling <br />
Schedule & Timing For Daily Vechile Reporting<br />
Booking, Payment Procedure & Amended / Cancellation<br />						<div class="headHr">
			            <p class="p7px b pl10px xlarge">Tour Itinerary</p>
			            </div>
			            
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 1:</b> Arrival Njp Station / (Ixb) Bagdogra Airport - Kalimpong
								</p>
								<p class="aj">On arrival at NJP Railway Station / (IXB) Bagdogra Airport, (500Ft / 150Mts) you will meet by our local representative who will assist you to board your vehicle to Kalimpong (3937 Ft / 1200 Mts, 75 Kms / 03 to 04 Hrs), Check in & over night at Hotel.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 2:</b> Kalimpong - Darjeeling
								</p>
								<p class="aj">Today after Breakfast visit Dello hills, Dr. Graham’s Home, Flower Nurseries, Jang-Dong-Palriffo Brang and Durbin Dara Hills. Transfer to Darjeeling (7380 Ft / 2250 Mts, 70 Kms / 03 to 04 Hrs), Overnight at Hotel. </p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 3:</b> Darjeeling
								</p>
								<p class="aj">After breakfast transfer to Mirik (5800 Ft / 1768 Mts / 50 Kms / 02 Hrs one way). Full day excursion of Pashupati Nagar (Indo-Nepal border) for shopping & Mirik Lake (Horse riding & Boat is available around the lake on direct payment basis).Evening back to Darjeeling and overnight at Hotel.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 4:</b> Darjeeling
								</p>
								<p class="aj">Early morning tour to Tiger Hills (8364 Ft / 2550 Mts at around 4 AM) to view sunrise over Kanchendzonga Peak (subject to clear weather). On way back visit Ghoom Monastery, Batasia Loop. After breakfast go for a half-day sightseeing of Japanese Temple, Peace pagoda, Padmaja Naidu Himalayan Zoological Park & Himalayan Mountaineering Institute (Closed on Thursday), Darjeeling Ropeway Ride (Ticket cost not included & will be approx INR 180.00 per person) Tenzing & Gombu Rock, Tibetan Refugee Self-Help Center (Closed on Sunday) & panoramic view of Tea Estate. Overnight at Hotel.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 5:</b> Darjeeling - Njp Railway Station / (Ixb) Bagdogra Airport
								</p>
								<p class="aj">After breakfast proceed to NJP Railway Station / (IXB) Bagdogra Airport (100 Kms / 03 to 04 Hrs) for your onward connection.<br />
</p>
								</td>
								</tr>
								</table>					
								</div>						<br />
												 <p class="headHr p7px b pl10px xlarge">Tour Detail</p>
			             <div class="data p15px aj">
										
						<p class="large b mb5px dif">Inclusions :</p>
						<ul>
															<li>Hotel</li>
																		<li>Meals</li>
																		<li>Sightseeing</li>
																		<li>Transport</li>
																		<li>Transfers</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Government Service Tax As Applicable (As On Date 01/04/2012 It Is 3.09%)</li><li>
Cost For Supplementary Service, Optional Tours, Up-Gradation Charges, Guide, Sightseeing Entrance Fees. </li><li>
Cost For Airfare, Train Fare, Insurance Premiums, Rafting Charges. </li><li>
Cost For Service Provided On A Personal Request. </li><li>
Cost For Personal Expenses Such As Laundry, Bottled Water, Soft Drinks, Incidentals, Porter Charges, Tips Etc. </li><li>
Cost For Any Other Service Not Mentioned Under The Cost Includes Head. </li><li>
Difference In Cost Arising Due To Change In Taxes By The Government Which Will Have To Be Collected Directly On Arrival. </li><li>
Difference In Cost Arising Due To Change In Fuel Price (Calculation Based On Petrol Inr 78 Per Liter & Diesel Inr 58 Per Liter) </li><li>
Difference In Cost Arising Due To Extra Usage Of Vehicle, Other Than Scheduled & Mentioned In The Itinerary. </li><li>
Difference In Cost Arising Due To Mishaps, Political Unrest, Natural Calamities Like - Landslides, Road Blockage, Etc. In Such Case Extra Will Have To Be Paid On The Spot By The Guest Directly. </li><li>
Supplement For Oneside Pickup Or Drop To/From Darjeeling/Kalimpong/Gangtok Will Be As Follows-</li><li>
Pick Up Or Drop From Drj / Gtk / Kpg	Nac Indica / Tata Sumo	Luxury Vehicle (Scorpio /Bolero/ Xylo)</li><li>
To Phuntsholing (Bhutan Border)	Inr 3000.00 Per Vehicle	Inr 4500.00 Per Vehicle</li><li>
To  Bhadrapur (Nepali Airport)	Inr 3000.00 Per Vehicle	Inr 4500.00 Per Vehicle</li><li>
The Following Points Are To Be Noted For Child Rate</li><li>
Children Above 10+ Years Will Be Charged 100% As Per Adult Rate (Epsr)</li><li>
Children Of 5+ To 10 Sharing Parent’s Room Will Be Charged As Per Cwb Or Cnb</li><li>
Children Below 5 Years Complimentary</li><li>
(Hotels Are Very Strict With The Child Policy. Please Carry The Age Proof So That It Can Be Produced When Asked For)</li><li>
For Further Information Please Click On The Below</li><li>
Important Note On Travellers Travelling To Sikkim & Darjeeling </li><li>
Schedule & Timing For Daily Vechile Reporting</li><li>
Booking, Payment Procedure & Amended / Cancellation</li></ul><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>~^#^~~^#^~<p><strong><u>Tour&nbsp;Terms and Conditions</u></strong>

<ul>
	<li>Per person rates (Rs) - Applicable on 2/3 persons staying together sharing the same room</li>
	<li>Package rates are subject to change without prior notice</li>
	<li>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.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</li>
	<li>The above package is not valid during national holidays, festivals &amp; long weekends</li>
	<li>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</li>
</ul>

<p><strong><u>Package does not includes</u></strong>

<p>&middot;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Meals not mentioned in the itinerary.&nbsp;<br />
Package does not include entry fees to monuments and places<br />
anything not mentioned in the package includes.<br />
Porte rage at hotels and airports, tips, insurance, laundry, liquors, wine, mineral water, telephone charges&nbsp;<br />
all items of personal nature.

<p>&middot;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Any cost arising due to natural calamities like landslides, roadblocks, etc. (to be borne by the clients directly on the spot).

<p>&middot;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Any increase in taxes or fuel leading to an increase in surface transportation &amp; land arrangements, which may come into effect prior to departure.

<p>&middot;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;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. 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.&nbsp;You are requested to make advance payment (50 % of the total tour cost) by credit card along with 2 % bank charges&nbsp;<u>OR</u>&nbsp;bank transfer to initiate with the bookings. 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.

<p><strong><u>PLEASE NOTE STANDARD CHECK IN TIME IS 1400 HRS &amp; CHECK OUT TIME IS 0900 HRS.</u></strong>

<p><u>PLEASE RECONFIRM THE ABOE PACKAGE WITH PAYMENT DETAILS AT THE EARLIEST.&nbsp;KINDLY DEPOSIT THE PACKAGE&nbsp;COST&nbsp;IN OUR ACCOUNT AT THE EARLIEST. PLEASE FIND OUR ACCOUNT DETAILS GIVEN BELOW</u>

<table border="0" cellpadding="0" cellspacing="0" style="width: 662px" width="662">
	<tbody>
		<tr>
			<td colspan="2" style="width: 662px">
			<p><strong>&nbsp;CUSTOMER&#39;S OPTION TO MAKE PAYMENTS THROUGH DEBIT CLEARING</strong>
			</td>
		</tr>
		<tr>
			<td style="width: 290px">
			<p><strong>&nbsp;Particulars</strong>
			</td>
			<td style="width: 372px">
			<p><strong>&nbsp;Details</strong>
			</td>
		</tr>
		<tr>
			<td style="width: 290px">
			<p>&nbsp;Company Name
			</td>
			<td style="width: 372px">
			<p>&nbsp;CHATURVEDI TRAVELS &amp; TOURS
			</td>
		</tr>
		<tr>
			<td style="width: 290px">
			<p>&nbsp;Beneficiary Name
			</td>
			<td style="width: 372px">
			<p>&nbsp;CHATURVEDI TRAVELS &amp; TOURS
			</td>
		</tr>
		<tr>
			<td style="width: 290px">
			<p>&nbsp;Beneficiary&#39;s Office Address
			</td>
			<td style="width: 372px">
			<p>&nbsp;29, WHITE HOUSE, CITY CENTER , GWALIOR 474001
			</td>
		</tr>
		<tr>
			<td style="width: 290px">
			<p>&nbsp;Beneficiary&#39;s Bank Name
			</td>
			<td style="width: 372px">
			<p>&nbsp;ICICI BANK LIMITED
			</td>
		</tr>
		<tr>
			<td style="width: 290px">
			<p>&nbsp;Beneficiary&#39;s Bank Address
			</td>
			<td style="width: 372px">
			<p>CITY CENTER , GWALIOR 474001&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
			</td>
		</tr>
		<tr>
			<td style="width: 290px">
			<p>&nbsp;Beneficiary&#39;s Bank A/c No.
			</td>
			<td style="width: 372px">
			<p>&nbsp;019705004795
			</td>
		</tr>
		<tr>
			<td style="width: 290px">
			<p>&nbsp;IFSC Code of the bank branch of the&nbsp; Beneficiary - For RTGS Transfer
			</td>
			<td style="width: 372px">
			<p>&nbsp;ICIC0000197
			</td>
		</tr>
		<tr>
			<td style="width: 290px">
			<p>&nbsp;IFSC Code of the bank branch of the Beneficiary - For NEFT Transfer
			</td>
			<td style="width: 372px">
			<p>&nbsp;ICIC0000197
			</td>
		</tr>
		<tr>
			<td style="width: 290px">
			<p>&nbsp;PAN NUMBER
			</td>
			<td style="width: 372px">
			<p>&nbsp;AFIPC8313B
			</td>
		</tr>
		<tr>
			<td style="width: 290px">
			<p>&nbsp;Type of Bank A/c ( Current A/c / Saving A/c or Cash Credit A/c)
			</td>
			<td style="width: 372px">
			<p>&nbsp;Current A/c
			</td>
		</tr>
		<tr>
			<td colspan="2" style="width: 662px">
			<p><strong>&nbsp;Certified that the particulars furnished above are correct as per our records.</strong>
			</td>
		</tr>
	</tbody>
</table>

<p><u>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</u>.&nbsp;&nbsp;

<p>&nbsp;Our rates are based on the prevailing rates as negotiated by us with the hotels.&nbsp; 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

<p>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.

<p>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.

<p><strong>Reservation Policy:</strong><br />
1. Confirmation of Hotel Rooms / House boat is subject to the availability.<br />
2.&nbsp;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.<br />
<br />
<strong>Cancellation Policy:-</strong><br />
1. Cancellation of the tour packages IS NON REFUNDABLE / Hotel Booking / Transportation or Non Utilization of the same: 100 % Retention...<br />
<br />
<strong>Terms &amp; Conditions:-</strong><br />
1.&nbsp;The above itinerary is suggested Tour Plan. The Company is responsible for only those services which are charged from the guest.&nbsp;&nbsp;All other services which are not paid by the guest to the Company are Suggested services and Company is nowhere bound to&nbsp;provide that service or pay the cost for the same.<br />
2.&nbsp;Check in and Check out Timing of the Hotel will be according to the timing of the respective Hotels.<br />
3.&nbsp;Company is not responsible for compensating any loss or additional cost incurred by the guest while taking the tour.<br />
4.&nbsp;Company is not responsible, nor liable for any damage, loss or injury caused to any passenger while taking the tour.<br />
5.&nbsp;Dollar rates are applicable only to foreign nationals &amp; Indians possessing foreign passports, while the INR package rates will be applicable to Indian nationals

<p>6.&nbsp;All the disputes are subject to Gwalior Jurisdiction only.<br />
7.&nbsp;&nbsp;Any Claim related to the Package must be brought to the notice of the Company within a week.

<h2 align="right">&nbsp;</h2>												</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="Darjeeling Tour 04 nights/05 days - 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="28199"/>
						</form>
						</div>
						
						";i:1;s:72:"Book Darjeeling Tour 04 nights/05 days - 4 Nights / 5 Days Tour Packages";i:2;s:130:"book darjeeling tour 04 nights/05 days - 4 nights / 5 days tour packages, valley tour packages, darjeeling, bagdogra tour packages";i:3;s:190:"Book Darjeeling Tour 04 nights/05 days - 4 Nights / 5 Days tour packages from Chaturvedi Travels and Tours - Get attractive 4 Nights / 5 Days Valley  tour packages for  Darjeeling, Bagdogra.";i:4;s:2403:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Darjeeling, Bagdogra"        
		                 },
		      "description": "Government Service Tax As Applicable (As On Date 01/04/2012 It Is 3.09%)
Cost For Supplementary Service, Optional Tours, Up-Gradation Charges, Guide, Sightseeing Entrance Fees. 
Cost For Airfare, Train Fare, Insurance Premiums, Rafting Charges. 
Cost For Service Provided On A Personal Request. 
Cost For Personal Expenses Such As Laundry, Bottled Water, Soft Drinks, Incidentals, Porter Charges, Tips Etc. 
Cost For Any Other Service Not Mentioned Under The Cost Includes Head. 
Difference In Cost Arising Due To Change In Taxes By The Government Which Will Have To Be Collected Directly On Arrival. 
Difference In Cost Arising Due To Change In Fuel Price (Calculation Based On Petrol Inr 78 Per Liter & Diesel Inr 58 Per Liter) 
Difference In Cost Arising Due To Extra Usage Of Vehicle, Other Than Scheduled & Mentioned In The Itinerary. 
Difference In Cost Arising Due To Mishaps, Political Unrest, Natural Calamities Like - Landslides, Road Blockage, Etc. In Such Case Extra Will Have To Be Paid On The Spot By The Guest Directly. 
Supplement For Oneside Pickup Or Drop To/From Darjeeling/Kalimpong/Gangtok Will Be As Follows-
Pick Up Or Drop From Drj / Gtk / Kpg	Nac Indica / Tata Sumo	Luxury Vehicle (Scorpio /Bolero/ Xylo)
To Phuntsholing (Bhutan Border)	Inr 3000.00 Per Vehicle	Inr 4500.00 Per Vehicle
To  Bhadrapur (Nepali Airport)	Inr 3000.00 Per Vehicle	Inr 4500.00 Per Vehicle
The Following Points Are To Be Noted For Child Rate
Children Above 10+ Years Will Be Charged 100% As Per Adult Rate (Epsr)
Children Of 5+ To 10 Sharing Parent’s Room Will Be Charged As Per Cwb Or Cnb
Children Below 5 Years Complimentary
(Hotels Are Very Strict With The Child Policy. Please Carry The Age Proof So That It Can Be Produced When Asked For)
For Further Information Please Click On The Below
Important Note On Travellers Travelling To Sikkim & Darjeeling 
Schedule & Timing For Daily Vechile Reporting
Booking, Payment Procedure & Amended / Cancellation",
		      "name": "Darjeeling Tour 04 nights/05 days",
		      "telephone": "+91-9826355115"
		    }
		    </script>
			";i:5;N;}