a:6:{i:0;s:21835:"				<div class="h1"><h1>Scenic Europe - Summer 2016 Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.grandindiatrip.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.grandindiatrip.com/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Scenic Europe - Summer 2016 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">Duniya Dekho - Europ</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						6 Nights / 7 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Paris, Brussels, Amsterdam, Frankfurt</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 95183 Per Person						</td>
						</tr>
												<tr>
						<td class="b p5px dif w125px vat">Special Offer </td>
						<td class="p5px pl0px dif vat">Visit - Lion Monument, Kappellbrucke (chapel Bridge), Jesuit Church<br />
<br />
Hotels Info<br />
<br />
City	Hotel Name<br />
Heppenheim	<br />
Hotel Starkenburger Hof Or Similar<br />
Chamonix	<br />
Hotel & Chalet Du Bois Or Similar<br />
Paris	<br />
Campanile Roissy Or Similar<br />
Waalwijk	<br />
Hotel Nh Waalwijk Or Similar</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Scenic Europe - Summer 2016 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="62291"/>
						</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/116250.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/116250.jpg"  width="150" height="150"    alt="Scenic Europe - Summer 2016 Tour" title="Scenic Europe - Summer 2016 Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					A journey of five different countries connecting with each other has advantages for the rushed tourist. Experience the Enchanting towns & classic scenery. A well planned itinerary striking a perfect balance between coach touring, sightseeing and leisure time<br />
<br />
All 'must see' sights covered.<br />
Easy Traveling, Smooth Sailing - On a Cox & Kings holiday you can just relax and we'll take care of everything.<br />
First Class Service - From location, service, to ambience, every detail is looked into, to ensure that your stay is an enjoyable one.<br />
A Friend In Need - Our Tour Manager Indeed - Our Tour Manager will at once make you feel at home. He'll show you the sights, guide you and take care of any problem, small or big!<br />
Great Meals - Stimulate your palate with a wide array of Indian dishes carefully selected and flavoured with authentic ingredients and spices.<br />
Sightseeing That Takes Your Breath Away - Enjoy the scenic journey through Europe with its ever changing landscape - from bustling cosmopolitan cities to tranquil lakes and alpine mountains. We offer a terrific holiday value that's impossible to match!<br />
Excursion to Aiguille Du Midi by cable car.<br />
Visit Mer De Glace.<br />
Get a unique view of all Paris from the 2nd level of Eiffel tower.<br />
Perfume shopping experience at Fragonard in Paris.<br />
Visit Cologne Cathedral.Visit - Lion Monument, Kappellbrucke (chapel Bridge), Jesuit Church<br />
<br />
Hotels Info<br />
<br />
City	Hotel Name<br />
Heppenheim	<br />
Hotel Starkenburger Hof Or Similar<br />
Chamonix	<br />
Hotel & Chalet Du Bois Or Similar<br />
Paris	<br />
Campanile Roissy Or Similar<br />
Waalwijk	<br />
Hotel Nh Waalwijk Or SimilarAn additional amount of INR 1,500/- per person is to be compulsorily paid by way of "Secure Your Booking Amount".<br />
Optional & Add-On tours unless mentioned otherwise.<br />
Cost of US $ 2,50,000 granted by the Reserve Bank of India under the Liberalised Remittance Scheme.<br />
Any increase in the airfare / taxes / routing charged by the airlines for ticket (presently calculated on 14th Aug, 2015).<br />
Airline and Hotel surcharges (if applicable) during high / festive season to be paid extra per person.<br />
Cost of extension of validity or deviation of your air ticket.<br />
Any increase in Rate of Euro leading to an increase in Tour Cost coming into effect prior to departure. However, the rate prevailing on the given day of payment will apply.<br />
Porterage at hotels, apartment, airports and seaports, tips, laundry, wines, mineral water, telephone charges, all items of personal nature and also food and drinks not forming part of the touring group's menu.<br />
Medical test and Premium cost of your Overseas Travel Insurance policy valid for passengers above 70 years of age.<br />
Anything not specifically mentioned in 'What Your Tour Price Includes' box.<br />
Government Service Tax 4.50% on gross bill, effective from 1st June 2016.15-0630-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 Frankfurt - Onto Chamonix
								</p>
								<p class="aj">This morning an enjoyable drive to Lucerne with its picturesque mountains, lakes, cowbells, alpine villages and meadows, the poignant Lion Monument, the covered, wooden Kapellbrucke (Chapel bridge), and the ornate Jesuit Church.<br />
You will have your first encounter with the marvels of Swiss shopping.<br />
Later enjoy a comfortable drive to the scenic splendour of Chamonix Mont Blanc. It's 'Love at first sight' as you enter the beautiful Chamonix Valley and the majestic mountains of the Mont Blanc range. After dinner, check into your hotel.<br />
Overnight in Chamonix area<br />
Dinner at an Indian restaurant</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> In Chamonix
								</p>
								<p class="aj">Today enjoy our excursion tour - a ride on the highest and most impressive cable car, the Aiguille du Midi, lifts you to 3842 meters for an unforgettable view of the Alps.<br />
The more fearless will take A STEP INTO THE VOID, onto a 2.50 m glass cage out over a 1000 m precipice. A product of modern architectural and technical prowess and a sensation packed experience.<br />
The Aiguille du Midi has its own postage stamp and a letterbox!<br />
Continue your excursion with a ride on the nostalgic red cog railway to Montenvers. The train climbs a steep track, through scenic Alpine scenery, to a stunning vantage point above the 'Mer de Glace' (sea of ice) Glacier.<br />
You know you've really arrived when you stand at 1913 meters, at the 'Mer de Glace', which is 7 kms long and 200 meters thick, with a surface dimension of 40 kms!<br />
A crystal gallery, a wildlife exhibition, an ice garden and the famous ice grotto 100 meters long, carved each year into the heart of the glacier, awaits you!<br />
After dinner, return to your hotel.<br />
Overnight in Chamonix<br />
Breakfast at the hotel and Dinner at an Indian restaurant.</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> Onto Paris
								</p>
								<p class="aj">Today, after an early breakfast, drive to Geneva, one of Switzerland's most privileged cities, said to have the second highest quality of living in the world!<br />
We begin the visit with a drive to the Palais des Nations (the European Headquarters of the United Nations) and the Musee Ariana.<br />
Be awestruck by the great white plume of the world's tallest fountain in Europe - the magnificent Jet d'Eau and pause for a photograph here and at the beautiful floral clock in the Jardin Anglais!<br />
Then enjoy a spectacular journey and experience the natural beauty and wonders of the alpine region as you enjoy a comfortable drive of approximately seven hrs. to Paris, the 'City of Lights'.<br />
On arrival in Paris after dinner, check into your hotel.<br />
Overnight in Paris<br />
Breakfast at the hotel and Dinner at an Indian restaurant</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> In Paris
								</p>
								<p class="aj">Today, start the day taking in the dazzling overview of the glittering city as you ascend by an elevator to the 2nd level of the Eiffel Tower!<br />
Enjoy a guided panoramic highlight city tour of famous monuments like the Pyramid of the Louvre, Garnier's Opera, the largest opera theatre in the world, the River Seine, the Place de la Concorde - the site of the infamous guillotine, the Champs Elysees - one of the most fashionable streets in the world, the Napoleanic Arc de Triomphe and the Hotel des Invalides.<br />
The evening is at leisure or you have the option to enjoy "Gala Evening in Paris" and experience the joie de vivre of 'Gaie Paris'.<br />
Overnight in Paris.<br />
Breakfast at the hotel and Dinner at an Indian restaurant.</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> Onto The Netherlands
								</p>
								<p class="aj">Today it's on to Brussels. On arrival a Walking Orientation tour takes you to the magnificent Gothic St. Michael and St. Gudula Cathedral. Then via Galeries Saint Hubert - the world's first shopping mall, opened in 1847, to the Grand Place, Europe's most beautiful square. This exquisite market square is the main tourist attraction of the city. Time permitting, shop here for world famous Belgian lace, chocolate and Belgian Waffles dusted with caramelized sugar. Mmmm!<br />
Visit the Manneken Pis, (photo stop) - the cheeky statue of a boy, representing the "irreverent spirit" of Brussels, which has drawn sightseers for centuries.<br />
Drive through Dutch countryside. Let the Windmills which still wield their magic enchant you. There's a photo stop at one. Spend some free time at Dam Square with the Nieuwe Kerk (New Church), the Royal Palace and the National Monument.<br />
Later drive to your hotel.<br />
Overnight in the Netherlands area.<br />
Breakfast at the hotel and Indian dinner at the 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 6:</b> Onto Germany
								</p>
								<p class="aj">Continue your scenic drive to Cologne, the metropolis on River Rhine, where on arrival you will visit the Cathedral - the first Gothic Church in the Rhineland with its characteristic spires.<br />
A short drive to Frankfurt. Enjoy some free time at the 'Altstadt' - old section of the town.<br />
After dinner, check into your hotel.<br />
Overnight in Frankfurt.<br />
Breakfast at the hotel and Dinner at an Indian restaurant.</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> Homeward Bound
								</p>
								<p class="aj">Good times need never end! As you get ready for the airport and your flight back home</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>An additional amount of INR 1,500/- per person is to be compulsorily paid by way of "Secure Your Booking Amount".</li><li>
Optional & Add-On tours unless mentioned otherwise.</li><li>
Cost of US $ 2,50,000 granted by the Reserve Bank of India under the Liberalised Remittance Scheme.</li><li>
Any increase in the airfare / taxes / routing charged by the airlines for ticket (presently calculated on 14th Aug, 2015).</li><li>
Airline and Hotel surcharges (if applicable) during high / festive season to be paid extra per person.</li><li>
Cost of extension of validity or deviation of your air ticket.</li><li>
Any increase in Rate of Euro leading to an increase in Tour Cost coming into effect prior to departure. However, the rate prevailing on the given day of payment will apply.</li><li>
Porterage at hotels, apartment, airports and seaports, tips, laundry, wines, mineral water, telephone charges, all items of personal nature and also food and drinks not forming part of the touring group's menu.</li><li>
Medical test and Premium cost of your Overseas Travel Insurance policy valid for passengers above 70 years of age.</li><li>
Anything not specifically mentioned in 'What Your Tour Price Includes' box.</li><li>
Government Service Tax 4.50% on gross bill, effective from 1st June 2016.</li></ul><br />
												<p class="large b mb5px dif">Specific Departure Dates :</p>June 2016	-	16<br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>* Some Advance Percentage of total booking amount 
* Airfare/Transport fare to be paid full at one time in advance.~^#^~* Upon cancellation, refund will be made after deducting the Retention Amount. 
* Retention Amount varies as per the number of days left before your package start date. ~^#^~						
    	<p class="h dif xlarge b mb5px">Package Cost Ex - Mumbai - Valid from 19th Jan, 2016 to 30th Sep, 2016</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Type</td>
				<td class="headHr p5px b">Price</td>
				<td class="headHr p5px b">Discount Offer</td>
				<td class="headHr p5px b">Total in INR After Discount</td>
			</tr>
			<tr>
				<td class="data p5px">Twin</td>
				<td class="data p5px">INR 93,143(EUR 466 + INR 56,049)</td>
				<td class="data p5px">INR 1,000</td>
				<td class="data p5px">INR 92,143</td>
			</tr>
			<tr>
				<td class="data p5px">Triple</td>
				<td class="data p5px">INR 93,143(EUR 466 + INR 56,049)</td>
				<td class="data p5px">INR 1,000</td>
				<td class="data p5px">INR 92,143</td>
			</tr>
			<tr>
				<td class="data p5px">Single</td>
				<td class="data p5px">INR 1,22,993(EUR 841 + INR 56,049)</td>
				<td class="data p5px">INR 1,000</td>
				<td class="data p5px">INR 1,21,993</td>
			</tr>
			<tr>
				<td class="data p5px">Child with bed</td>
				<td class="data p5px">INR 85,571(EUR 396 + INR 54,049)</td>
				<td class="data p5px">INR 1,000</td>
				<td class="data p5px">INR 84,571</td>
			</tr>
			<tr>
				<td class="data p5px">Child without bed</td>
				<td class="data p5px">INR 81,909(EUR 350 + INR 54,049)</td>
				<td class="data p5px">INR 1,000</td>
				<td class="data p5px">INR 80,909</td>
			</tr>
			<tr>
				<td class="data p5px">Infant</td>
				<td class="data p5px">INR 39,999(EUR + INR 39,999)</td>
				<td class="data p5px">INR 0</td>
				<td class="data p5px">INR 39,999</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Package Cost Ex - Delhi - Valid from 19th Jan, 2016 to 30th Sep, 2016</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="data p5px">Type</td>
				<td class="data p5px">Price</td>
				<td class="data p5px">Discount Offer</td>
				<td class="data p5px">Total in INR After Discount</td>
			</tr>
			<tr>
				<td class="data p5px">Twin</td>
				<td class="data p5px">INR 96,143(EUR 466 + INR 59,049)</td>
				<td class="data p5px">INR 1,000</td>
				<td class="data p5px">INR 95,143</td>
			</tr>
			<tr>
				<td class="data p5px">Triple</td>
				<td class="data p5px">INR 96,143(EUR 466 + INR 59,049)</td>
				<td class="data p5px">INR 1,000</td>
				<td class="data p5px">INR 95,143</td>
			</tr>
			<tr>
				<td class="data p5px">Single</td>
				<td class="data p5px">INR 1,25,993(EUR 841 + INR 59,049)</td>
				<td class="data p5px">INR 1,000</td>
				<td class="data p5px">INR 1,24,993</td>
			</tr>
			<tr>
				<td class="data p5px">Child with bed</td>
				<td class="data p5px">INR 88,571(EUR 396 + INR 57,049)</td>
				<td class="data p5px">INR 1,000</td>
				<td class="data p5px">INR 87,571</td>
			</tr>
			<tr>
				<td class="data p5px">Child without bed</td>
				<td class="data p5px">INR 84,909(EUR 350 + INR 57,049)</td>
				<td class="data p5px">INR 1,000</td>
				<td class="data p5px">INR 83,909</td>
			</tr>
			<tr>
				<td class="data p5px">Infant</td>
				<td class="data p5px">INR 39,999(EUR + INR 39,999)</td>
				<td class="data p5px">INR 0</td>
				<td class="data p5px">INR 39,999</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Package Cost Ex - Kolkata - Valid from 19th Jan, 2016 to 30th Sep, 2016</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Type</td>
				<td class="headHr p5px b">Price</td>
				<td class="headHr p5px b">Discount Offer</td>
			</tr>
			<tr>
				<td class="data p5px">Twin</td>
				<td class="data p5px">INR 1,03,143(EUR 466 + INR 66,049)</td>
				<td class="data p5px">INR 1,000</td>
			</tr>
			<tr>
				<td class="data p5px">Triple</td>
				<td class="data p5px">INR 1,03,143(EUR 466 + INR 66,049)</td>
				<td class="data p5px">INR 1,000</td>
			</tr>
			<tr>
				<td class="data p5px">Single</td>
				<td class="data p5px">INR 1,32,993(EUR 841 + INR 66,049)</td>
				<td class="data p5px">INR 1,000</td>
			</tr>
			<tr>
				<td class="data p5px">Child with bed</td>
				<td class="data p5px">INR 95,571(EUR 396 + INR 64,049)</td>
				<td class="data p5px">INR 1,000</td>
			</tr>
			<tr>
				<td class="data p5px">Child without bed</td>
				<td class="data p5px">INR 91,909(EUR 350 + INR 64,049)</td>
				<td class="data p5px">INR 1,000</td>
			</tr>
			<tr>
				<td class="data p5px">Infant</td>
				<td class="data p5px">INR 39,999(EUR + INR 39,999)</td>
				<td class="data p5px">INR 0</td>
			</tr>
		</table></div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Scenic Europe - Summer 2016 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="62291"/>
						</form>
						</div>
						
						";i:1;s:71:"Book Scenic Europe - Summer 2016 Tour - 6 Nights / 7 Days Tour Packages";i:2;s:148:"book scenic europe - summer 2016 tour - 6 nights / 7 days tour packages, heritage tour packages, paris, brussels, amsterdam, frankfurt tour packages";i:3;s:192:"Grand India Tours & Travels offers Scenic Europe - Summer 2016 Tour - 6 Nights / 7 Days tour package, budget Heritage tour packages for Paris, Brussels, Amsterdam, Frankfurt at exciting price.";i:4;s:3268:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Paris, Brussels, Amsterdam, Frankfurt"        
		                 },
		      "description": "A journey of five different countries connecting with each other has advantages for the rushed tourist. Experience the Enchanting towns & classic scenery. A well planned itinerary striking a perfect balance between coach touring, sightseeing and leisure time

All 'must see' sights covered.
Easy Traveling, Smooth Sailing - On a Cox & Kings holiday you can just relax and we'll take care of everything.
First Class Service - From location, service, to ambience, every detail is looked into, to ensure that your stay is an enjoyable one.
A Friend In Need - Our Tour Manager Indeed - Our Tour Manager will at once make you feel at home. He'll show you the sights, guide you and take care of any problem, small or big!
Great Meals - Stimulate your palate with a wide array of Indian dishes carefully selected and flavoured with authentic ingredients and spices.
Sightseeing That Takes Your Breath Away - Enjoy the scenic journey through Europe with its ever changing landscape - from bustling cosmopolitan cities to tranquil lakes and alpine mountains. We offer a terrific holiday value that's impossible to match!
Excursion to Aiguille Du Midi by cable car.
Visit Mer De Glace.
Get a unique view of all Paris from the 2nd level of Eiffel tower.
Perfume shopping experience at Fragonard in Paris.
Visit Cologne Cathedral.Visit - Lion Monument, Kappellbrucke (chapel Bridge), Jesuit Church

Hotels Info

City	Hotel Name
Heppenheim	
Hotel Starkenburger Hof Or Similar
Chamonix	
Hotel & Chalet Du Bois Or Similar
Paris	
Campanile Roissy Or Similar
Waalwijk	
Hotel Nh Waalwijk Or SimilarAn additional amount of INR 1,500/- per person is to be compulsorily paid by way of "Secure Your Booking Amount".
Optional & Add-On tours unless mentioned otherwise.
Cost of US $ 2,50,000 granted by the Reserve Bank of India under the Liberalised Remittance Scheme.
Any increase in the airfare / taxes / routing charged by the airlines for ticket (presently calculated on 14th Aug, 2015).
Airline and Hotel surcharges (if applicable) during high / festive season to be paid extra per person.
Cost of extension of validity or deviation of your air ticket.
Any increase in Rate of Euro leading to an increase in Tour Cost coming into effect prior to departure. However, the rate prevailing on the given day of payment will apply.
Porterage at hotels, apartment, airports and seaports, tips, laundry, wines, mineral water, telephone charges, all items of personal nature and also food and drinks not forming part of the touring group's menu.
Medical test and Premium cost of your Overseas Travel Insurance policy valid for passengers above 70 years of age.
Anything not specifically mentioned in 'What Your Tour Price Includes' box.
Government Service Tax 4.50% on gross bill, effective from 1st June 2016.15-0630-09",
		      "name": "Scenic Europe - Summer 2016 Tour",
		      "telephone": "+91-9415285186"
		    }
		    </script>
			";i:5;N;}