a:6:{i:0;s:34427:"				<div class="h1"><h1>Grand Bargain Tour of Europe</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.geetcompany.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.geetcompany.com/holiday-tour-packages.htm" title="Holiday Tour Packages">Holiday Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Grand Bargain Tour of Europe</p>
				<br />
				
									<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>
					
					<table class="w100 formTable imgWidth">
					<tr>
					
											<td class="p10px vat imgWidth150 w150px">
						<div class="demo-wrap">
						<ul class="lsn m0px p0px" id="detailslider1">
															<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_1/22362/9215.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_1/22362/9215.jpg"  width="150" height="150"    alt="The Grand Bargain Tour" title="The Grand Bargain Tour" /></a></p></div></li>
																		<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_1/22362/22387.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_1/22362/22387.jpg"  width="150" height="150"    alt="Grand Bargain Tour of Europe" title="Grand Bargain Tour of Europe" /></a></p></div></li>
																		<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_1/22362/22388.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_1/22362/22388.jpg"  width="150" height="150"    alt="Grand Bargain Tour of Europe" title="Grand Bargain Tour of Europe" /></a></p></div></li>
															</ul>
						</div>
						</td>
											
					<td class="p10px">
											<p class="mb5px"><b>Duration :</b> 
						14 Nights / 15 Days 
						</p>
												<p class="mb5px"><b>Destination Covered :</b> London, Italy, Vatican City</p>
												<p><b>Price (Starting From) :</b> <span class="dif">On Request</span></p>
												<br />
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.geetcompany.com/travel-inquiry.htm">
						<input type="hidden" name="subject" value="Grand Bargain Tour of Europe - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>
						<a href="#" onclick="document.getElementById('frmpackagedetail').submit();" class="buttonBig p10px20px c5px b large dib">Book Your Tour</a>
						<input type="hidden" name="pkg_slno" value="9539"/>
						</form>
						</p>
											</td>
					</tr>
					</table>
										<br />
					
					<div class="packageTabs myTabs horizontal mc"><!--MY TABS STARTS-->
					<ul class="fo lsn m0px p0px">
					
											<li id="tab2"><a href="#data2">Itinerary</a></li>
												<li id="tab4"><a href="#data4">Tour Detail</a></li>
												<li id="tab5"><a href="#data5">Rate Card</a></li>
												<li id="tab6"><a href="#data6">Terms &amp; Conditions</a></li>
											</ul>
					
					
											<div class="ic bdr" id="data2"><!--DATA2 START-->
						<br />
						<ul class="lsn m0px p0px">
									<li>
									<p class="b mb5px">Day 1: Arrive into London, capital of United Kingdom.
									</p>
									<div class="data p10px">Bon voyage! Today you are off on your exciting European tour with Thomas Cook, as you board your flight to London. On arrival, you will be greeted by your friendly Thomas Cook Tour Manager outside the baggage hall. We shall then proceed to your conveniently located hotel and check-in first. Freshen up and relax in the comfort of your hotel room. Later this evening, we proceed to visit the most beautifully carved out of Italian Carrara marble, the Swaminarayan Temple. Tonight, enjoy a delicious Indian dinner at an Indian restaurant. Overnight at Hotel Park Inn / St. Giles / Quality or similar in London.</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 2: Enjoy the many sights of London on your Guided City Tour.
									</p>
									<div class="data p10px">After a Continental buffet breakfast, we leave for a guided city tour with an expert English-speaking guide who will explain to you all the highlights of London's landmarks: Buckingham Palace, Hyde Park, the Big Ben, Westminster Abbey, Houses of Parliament, Trafalgar Square, Piccadilly Circus, Tower Bridge, River Thames and many more. Relish a hot Indian or local meal for lunch. We then take you to visit the famous Madame Tussaud's wax museum. This museum houses a unique collection of world's largest wax works of famous personalities, including India's top leaders and film stars. Next, we take you on the famous London Eye - one of the world's largest observation wheels. Be enchanted by this new and novel way of seeing the city from a bird's eye view, as the London Eye takes you on a 30 minute flight, rising to 450 feet above the river Thames and a panorama of some of London's most famous streets, churches, palaces and monuments are spread out before you. This evening, Thomas Cook has specially arranged a guided tour of the world famous Wimbledon museum, a dream for every Tennis lover. On arrival, embark on a stunning multi-dimensional tour of the traditions, the Championship trophies and the sights and sounds that have made Wimbledon the most coveted. After a nostalgic evening proceed to the restaurant where a delicious Indian Dinner awaits you. Overnight at Hotel Park Inn / St. Giles / Quality or similar in London.</div>					
										<p><b>Meals : </b> Continental Buffet Breakfast.</p>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 3: Bien Venue! Welcome to the glamour capital of the world.
									</p>
									<div class="data p10px">Check out of your hotel after a continental buffet / boxed breakfast and proceed by Le Shuttle to the glamorous city of Paris. Indian lunch will be provided. On arrival in Paris, we take you on an exhilarating city tour with an English - speaking local guide, who will show you many of the best - loved Parisian sights - Alexander Bridge, Arc de Triomphe, Concorde Square, Opera House, Invalides, Champs Elysees and much more. Next, we proceed to visit the top of the Eiffel Tower (3rd level), from where you will have a splendid view of this beautiful city. Later in the evening, a hot Indian dinner awaits you at an Indian restaurant. Tonight, you have a chance to experience the glamour of the famous Lido Show - an unforgettable experience on your tour. Overnight at Hotel Park Inn / Mercure / Forest Hill or similar in Paris.</div>					
										<p><b>Meals : </b> Continental Buffet Breakfast.</p>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 4: Today, join us on a fun - filled trip to Disney Park OR Disney Studios - Europe's most famous attrac
									</p>
									<div class="data p10px">After a Continental buffet breakfast at the hotel, join us for some fun, adventure and entertainment on our full-day tour to Disney Park and enjoy the many rides (all included) OR you can visit the Disney Studios and be amazed by the stunning stunt shows, watch a film being made and see real-life sets where famous movies were created. Indian lunch will be provided. Later, enjoy a romantic Seine cruise as we sail past some of the historical monuments on the river Seine. Tonight, enjoy Indian or local dinner at an Indian restaurant. Overnight at Hotel Park Inn / Mercure / Forest Hill or similar in Paris.<br />
<br />
<b>OR</b><br />
<br />
After a continental buffet breakfast at your hotel, we take you on a guided tour of Versailles Palace - set on impressive grounds and steeped in memories of major historic events. Visit the Chateau of Versailles, the most prestigious monuments of the world's artistic heritage. Vast chambers and private apartments of unimaginable luxury include an opera hall, a chapel, and the famous Hall of Mirrors. After a hot Indian lunch, we take you to visit the world-renowned Louvre Museum to see the incomparable and the most prestigious painting of 'Mona Lisa'-Leonardo da Vinci's masterpiece and many more. You also have some free time to shop for perfumes and souvenirs. Enjoy a romantic seine cruise as we sail past some of the historical monuments on the river seine. Tonight, enjoy a delicious local or Indian dinner before we drive back to the hotel. Overnight at Hotel Park Inn / Mercure / Forest Hill or similar in Paris.</div>					
										<p><b>Meals : </b> Continental Buffet Breakfast.</p>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 5: Onto Brussels, the capital of the European Union.
									</p>
									<div class="data p10px">After a Continental buffet breakfast check out and sit back in your coach as we drive to Brussels. This afternoon, enjoy Indian lunch. On arrival, we visit the world renowned Grand Place and the legendary Mannekin Pis statue. Drive past St. Michael's Church. En route a photo stop at the Atomium is also included. After a hot delicious Indian meal for dinner, transfer to your hotel and check-in. Overnight at Hotel Amrath / Best Western / Thon or similar in Breda/ Antwerp / Brussels or similar.</div>					
										<p><b>Meals : </b> Continental Buffet Breakfast.</p>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 6: Amsterdam - a city full of surprises. Visit Madurodam and see Holland in miniature. Also visit Keu.
									</p>
									<div class="data p10px">After a Continental buffet breakfast, sit back and relax in your coach as we proceed to Keukenhof - the largest spring garden in the world. Bulbs of colourful tulips bloom only till May 20th. Be enchanted by the indoor floral displays and colourful flower beds amongst ancient trees. 21st May onwards, visit Volendam. Marvel at the beauty of this picturesque town, its people in graceful traditional costumes, its little wooden houses and the quaint harbour will amaze your imagination. Visit a cheese farm and a wooden shoe factory. See a demonstration of how cheese is made and wooden shoes are carved out of wooden blocks. You also have a chance to savour some cheese. Next, visit Madurodam, all throughout the year, where you can see most of Holland in miniature, replicated in minute detail on a 1:25 scale. Next, arrive into Amsterdam. This afternoon, you enjoy a delicious hot Indian or local meal for lunch. Later board your glass-topped boat as we sail through the canals for an exciting canal cruise. The city’s colourful past comes alive with its 1,000 bridges and fine old houses on your tour of Amsterdam. Later, visit the famous Dam Square - the real heart of Amsterdam, where the Royal Palace, the Nieuwe Kerk and the War Memorial overlooks this vast and bustling open space. After a hot Indian dinner drive back to your hotel. Overnight at Hotel Amrath / Best Western / Thon or similar in Breda/ Antwerp / Brussels or similar.</div>					
										<p><b>Meals : </b> Continental Buffet Breakfast.</p>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 7: Visit the biggest Gothic Cathedral in Europe - the Cologne Cathedral. Enjoy a romantic cruise.
									</p>
									<div class="data p10px">After a Continental buffet breakfast, check out and proceed to Cologne. Visit the impressive Cologne Cathedral, a fine example of amazing Gothic architecture. This afternoon, Indian lunch will be provided. Later we proceed to board your scenic cruise on the River Rhine. Cruising down the Rhine, you will pass steep slopes covered with vineyards. The River Rhine is one of Europe's major navigable rivers. Later, board your coach again and drive to Heidelberg, situated on the banks of the river Neckar. On arrival stroll down Alstadt to get a feel of real European experience of the past. This evening, enjoy a sumptuous Indian dinner at a restaurant, before you drive to your hotel. Overnight at Hotel Holiday Inn Express / Park Inn / Mercure or similar in Frankfurt / Heppenheim / Mannheim.</div>					
										<p><b>Meals : </b> Continental Buffet Breakfast.</p>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 8: On to Hofgutsternen - heart of the Black Forest. View the spectacular Rhine Falls in Schaffhausen.
									</p>
									<div class="data p10px">After a Continental buffet breakfast at the hotel, check out, sit back and relax in your coach as we drive to Hofgutsternen. This is the heart of the Black Forest, surrounded by dark fir forests, fairy tale woods and flowering meadows. Here is the home of the world-famous cuckoo clock. Get invited for a free demonstration and buy one for your home - a prized possession. Today, the choice is yours to enjoy an Indian lunch or local meal with an authentic black forest pastry. Next, proceed to Switzerland, enroute visit the Rhine Falls - the largest waterfalls in Europe. This evening, enjoy a hot Indian dinner at a restaurant. Overnight at Hotel Novotel / Park Inn or similar in Zurich OR Hotel Movenpick / Arcade / Angels Lodge / Victoria or similar in Central Switzerland.</div>					
										<p><b>Meals : </b> Continental Buffet Breakfast.</p>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 9: Day is at leisure OR you have a chance to join us on an all inclusive Alpine excursion tour.
									</p>
									<div class="data p10px">This morning, after a Continental buffet breakfast, the day is at leisure OR you can join us on an adventurous ride to visit Jungfraujoch - The Top of Europe, for a memorable encounter with snow and ice - a genuine 'high-point' of your tour! Sit back in your coach as we proceed to the beautiful town of 'Lauterbrunnen', where the excitement continues. You will be amazed at the scenic splendour that you see from aboard the 'cogwheel' train, which takes you to a height of 3,454 metres to reach Jungfraujoch! This is a trip to another world - a wonderful world of eternal ice and snow. Experience the magic of the mountains and visit the Ice Palace on top of the longest glacier in the Alps. A visit to the Sphinx is also included. Later, we visit Interlaken, a charming city nestled between two lakes and surrounded by the splendid Bernese Oberland Mountains, where you will enjoy a delicious Indian meal for lunch. Treasure these wonderful moments as you drive back to your hotel. This evening enjoy a sumptuous Indian dinner. Overnight at Hotel Movenpick / Arcade / Angels Lodge / Victoria or similar in Central Switzerland.</div>					
										<p><b>Meals : </b> Continental Buffet Breakfast.</p>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 10: Today, get set for a day full of fun and excitement as we take you to visit Mt. Titlis.
									</p>
									<div class="data p10px">After a Continental buffet breakfast at your hotel, we take you on one of the most memorable experiences of your Europe tour - visiting Mt. Titlis and Lucerne. Adventure awaits you in a sensational cable-car ride up to Mt. Titlis. Marvel at the world's first revolving cable-car ride, a truly once-in-a lifetime experience. Remain spellbound as you ascend the snow-clad mountains. Experience the snow and ice on top of Mt. Titlis. At 3,020 metres a breathtaking panorama unfolds. Later we proceed to scenic Lucerne. Enjoy a delicious Indian lunch on arrival. Next, you will visit the Lion Monument and the Kapell Brucke (wooden bridge). Here you will also have some free time to shop for famous Swiss watches, knives and chocolates. Enjoy a scenic cruise on the serene waters of Lake Lucerne. Tonight, after a delicious Indian dinner return back to your hotel. Overnight at Hotel Movenpick / Arcade / Angels Lodge / Victoria or similar in Central Switzerland.</div>					
										<p><b>Meals : </b> Continental Buffet Breakfast.</p>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 11: Onto Innsbruck, in picturesque Austria at the crossroads of Europe. Visit Swarovski Museum.
									</p>
									<div class="data p10px">This morning, after a Continental buffet breakfast, check out and drive through the Arlberg Tunnel in picturesque Austria. After a hot Indian meal for lunch proceed to Wattens, where you will visit the world-famous Swarovski Crystal Museum. Enjoy a fascinating experience in to the 'world of crystals'. An experience that leaves you amazed at the dazzling glitter as you walk through this museum. A great opportunity to buy a souvenir for your family. Later arrive in Innsbruck and proceed for an orientation tour of this beautiful city. See the Golden Roof and the Maria Theresien Strasse. Stroll on cobblestone pathways and get a feel of old-world European charm. The splendid scenes of the Alps in the background are a perfect picture-postcard setting. Tonight enjoy an Indian or local dinner especially prepared for you. Overnight at Hotel Kronen / Olympia / Alpine Park or similar in Seefeld/ Innsbruck.</div>					
										<p><b>Meals : </b> Continental Buffet Breakfast.</p>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 12: Romantic Venice - Crossed by canals, beautiful monuments, the city that inspires poetry and passion.
									</p>
									<div class="data p10px">After a Continental buffet breakfast at the hotel, check out and drive towards Italy. Indian lunch will be provided. Proceed to the pier and board a private boat which will take you to the heart of the traditional city of Venice - The St. Mark's Square. This astonishingly wonderful lagoon city is a special delight to visitors. Sail over the Guidecca Canal, as you catch a glimpse of the serene waters of the Adriatic Sea. On arrival, admire The St. Mark's square with the Basilica, Doge's Palace, Campanile and Bridge of Sighs. You will be taken on an unforgettable gondola ride through the smaller canals for a true picture of this lagoon city. Also visit the Murano Glass showroom. This evening, after a hot delicious Indian dinner check into your hotel. Overnight at Hotel Unaway / Petrarca / Europa or similar in Occhiobello / Rovigo or similar.</div>					
										<p><b>Meals : </b> Continental Buffet Breakfast.</p>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 13: Guided city tour of Florence - the cradle of the Renaissance, former home of the Medicis. Pisa.
									</p>
									<div class="data p10px">After a Continental buffet breakfast at your hotel, check out and proceed to Florence. Meet your English-speaking local guide for a city tour of Florence, including the Duomo, the Campanile, the Baptistry with its Gates to Paradise, Piazza Della Signoria - an open air museum of sculptures, the famous Ponte Vecchio bridge across the river Arno and Santa Croce where Michelangelo, Galileo and many famous Italian personalities are buried. Drive to Piazzale Michelangelo, a square on top of a hill with its replica of the impressive statue of David and also get a bird’s eye view of the city of Florence. After a delicious Indian lunch drive to Pisa to visit the Square of Miracles. Remain spellbound as you approach this precariously leaning tower. Photograph your family with the Leaning Tower in the backdrop. You also have some free time to shop. After a sumptuous hot Indian dinner at a restaurant check into your hotel. Overnight at Hotel Planet / Idea or similar in Arezzo / Pisa or similar.</div>					
										<p><b>Meals : </b> Continental Buffet Breakfast.</p>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 14: Visit Rome on a Guided City Tour. Visit the world's smallest country - the Vatican City.
									</p>
									<div class="data p10px">After a Continental buffet breakfast this morning, check out of your hotel, board your coach and proceed to Rome. Today, you have a choice to enjoy an Indian or local meal for lunch at a restaurant in Rome. Next proceed for a city tour of Rome with an expert English-speaking guide. Visit the Vatican City - the smallest country in the world (shorts or sleeveless vests not allowed). First stop at the Vatican Museum, with a visit to the world -famous Sistine Chapel - a pure source of inspiration for art lovers and tourists alike, specially included on your tour. This will be followed by a visit to the holy Basilica of St. Peter's - the incomparable home of architectural and artistic masterpieces by Michelangelo and Bernini, which will leave you awestruck. Next, see the imposing Colosseum, a vast amphitheatre, known for its gladiator fights. Also see the Victor Emmanuel Monument, the Roman Forum, Trevi Fountain and many 6 more sights of this historic city. Tonight, we have arranged a delicious Indian dinner at a restaurant. Later, check into your hotel and relax. Overnight at Hotel Idea / Best Western / Antonella or similar in Rome.</div>					
										<p><b>Meals : </b> Continental Buffet Breakfast.</p>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 15: Fly Back Home.
									</p>
									<div class="data p10px">After a continental buffet/boxed breakfast, we check out and proceed to the airport for your flight back home. Arrive home with pleasant memories of your European tour, which we are sure you will treasure for a lifetime. Do spare a few minutes to fill in the feedback form and hand it to your Tour Manager. Your valued suggestions will be most appreciated.</div>					
										<p><b>Meals : </b> Continental Buffet Breakfast.</p>					
									</li>
									<br />					
							</ul>						<!--DATA2 EMD--></div>
											
						<div class="ic bdr" id="data4"><!--DATA4 START-->
						<br />
						<b>What Your Tour Price Does Not Include</b><br><br />
If you wish to travel in advance i.e., before the published departure date as mentioned in the brochure or like to come back on a later date after the tour ends, there will be an additional charge that will be applicable (subject to availability of seats for the given dates & ticket validity) which will be advised to you by our sales staff / travel agent. Kindly note, the deviation will be actioned only 30 days prior to departure date.<br />
In case your tour is not ending in United Kingdom and you wish to return from London or any other city in the United Kingdom, the UK departure tax will be advised on confirmation of the deviation date.<br />
Cost of Basic Travel Quota equivalent to USD 10,000.<br />
Any increase in the airfare charged by the airline on your air ticket (presently calculated as of 31st August 2012 rates).<br />
Taxes as applicable are extra.<br />
The tour cost does not include POE charges and passport charges.<br />
No porterage included.<br />
Any expenses of personal nature such as porterage, laundry expenses, wines, mineral water, food and drink not in the regular menu provided by us, minibar, telephone calls etc.<br />
Tips of any nature i.e. drivers, guides, etc.<br />
Meals other than that what is mentioned in your itinerary.<br />
Cost of excursions, city sightseeing, entrance fees and local guides availed of by the passengers, other than that mentioned in 'What your tour price includes'.<br />
Cost of Lido Show and Jungfraujoch.							<p class="b mb5px dif">Inclusions :</p>
							<ul>
																	<li>Sightseeing</li>
																	</ul>
							<br />
														<p class="b mb5px dif">Exclusions :</p> <ul><li>What Your Tour Price Does Not Include<br></li><li>
If you wish to travel in advance i.e., before the published departure date as mentioned in the brochure or like to come back on a later date after the tour ends, there will be an additional charge that will be applicable (subject to availability of seats for the given dates & ticket validity) which will be advised to you by our sales staff / travel agent. Kindly note, the deviation will be actioned only 30 days prior to departure date.</li><li>
In case your tour is not ending in United Kingdom and you wish to return from London or any other city in the United Kingdom, the UK departure tax will be advised on confirmation of the deviation date.</li><li>
Cost of Basic Travel Quota equivalent to USD 10,000.</li><li>
Any increase in the airfare charged by the airline on your air ticket (presently calculated as of 31st August 2012 rates).</li><li>
Taxes as applicable are extra.</li><li>
The tour cost does not include POE charges and passport charges.</li><li>
No porterage included.</li><li>
Any expenses of personal nature such as porterage, laundry expenses, wines, mineral water, food and drink not in the regular menu provided by us, minibar, telephone calls etc.</li><li>
Tips of any nature i.e. drivers, guides, etc.</li><li>
Meals other than that what is mentioned in your itinerary.</li><li>
Cost of excursions, city sightseeing, entrance fees and local guides availed of by the passengers, other than that mentioned in 'What your tour price includes'.</li><li>
Cost of Lido Show and Jungfraujoch.</li></ul><br />
													<!--DATA4 EMD--></div>
							
						<div class="ic bdr" id="data5"><!--DATA5 START-->
						<br />
						
    	<p class="h dif xlarge b mb5px">Departure Dates for Euro Disney - Ex-Mumbai / Delhi / Chennai / Hyderabad / Ahmedabad / Bengaluru / Kolkata</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Months</td>
				<td class="headHr p5px b">Dates</td>
			</tr>
			<tr>
				<td class="data p5px">April</td>
				<td class="data p5px">3, 7, 10, 14, 17, 19, 20, 21, 24, 26, 27, 28</td>
			</tr>
			<tr>
				<td class="data p5px">May</td>
				<td class="data p5px">1, 3, 4, 5, 7, 8, 10, 11, 12, 14, 15, 17, 19, 21, 22, 24, 25, 26, 29, 31</td>
			</tr>
			<tr>
				<td class="data p5px">June</td>
				<td class="data p5px">2, 5, 7, 9, 12, 14, 16, 19, 21, 23, 26, 28, 30</td>
			</tr>
			<tr>
				<td class="data p5px">July</td>
				<td class="data p5px">5, 7, 12, 19, 26</td>
			</tr>
			<tr>
				<td class="data p5px">August</td>
				<td class="data p5px">2, 9, 16, 23, 30</td>
			</tr>
			<tr>
				<td class="data p5px">September</td>
				<td class="data p5px">6, 13, 20, 27</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Departure Dates for Versailles Palace & Louvre Museum - Ex-Mumbai / Delhi / Chennai / Hyderabad / Ahmedabad / Bengaluru / Kolkata</p>
    	<div class="otherDetails aj">Pre/ Post-Tour Accommodation in London / Paris / Rome<br>
<ul><li>(Includes accommodation per person per night and Continental breakfast. Does not include transfers.).</li></ul></div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Months</td>
				<td class="headHr p5px b">Dates</td>
			</tr>
			<tr>
				<td class="data p5px">April</td>
				<td class="data p5px">1, 8, 15, 22, 29</td>
			</tr>
			<tr>
				<td class="data p5px">May</td>
				<td class="data p5px">6, 13, 16, 20, 27, 30</td>
			</tr>
			<tr>
				<td class="data p5px">June</td>
				<td class="data p5px">3, 10, 17, 24</td>
			</tr>
			<tr>
				<td class="data p5px">July</td>
				<td class="data p5px">1, 8, 15, 22, 27</td>
			</tr>
			<tr>
				<td class="data p5px">August</td>
				<td class="data p5px">5, 12, 19, 26</td>
			</tr>
			<tr>
				<td class="data p5px">September</td>
				<td class="data p5px">2, 9, 16, 30</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px"><b>Highlights</b></p>
    	<div class="otherDetails aj"><ul><li>A complete tour at an honest price with maximum quality sightseeing and minimum traveling time.</li><li>Hot delicious unlimited Indian Jain / vegetarian / non vegetarian meals included.</li><li>Enjoy daily Continental buffet breakfast.</li><li>A choice of local meals in 06 different countries.</li><li>A relaxed tour with time for shopping.</li><li>Guided city tour of London.</li><li>Visit Madame Tussaud's wax museum.</li><li>Ride on the London Eye.</li><li>Guided tour of the world famous Wimbledon Lawns and Tennis museum in London.</li><li>Visit the famous Swaminarayan Temple in London.</li><li>Guided city tour of Paris.</li><li>Visit the 3rd level of the Eiffel Tower.</li><li>Enjoy romantic Seine cruise in Paris.</li><li>Fun-filled trip to Euro Disney or visit the magnificent Versailles Palace and the Louvre Museum.</li><li>Chance to experience the glamour of the famous Lido Show.</li><li>Orientation tour of Brussels.</li><li>See both Keukenhof and Madurodam.</li><li>Catch a breathtaking view of Amsterdam city on a canal cruise.</li><li>Visit the historical Cologne Cathedral.</li><li>Enjoy a scenic cruise on the river Rhine.</li><li>A stroll down the Alstadt in Heidelberg.</li><li>Visit Hofgutsternen, right in the heart of the Black Forest.</li><li>View the magnificent Rhine falls in Schaffhausen.</li><li>Stay 03 nights in scenic Switzerland.</li><li>Chance to cherish an experience to be on top of Europe - Jungfraujoch.</li><li>Visit Mt. Titlis in the world's first revolving cable car.</li><li>Scenic cruise on Lake Lucerne.</li><li>See the Golden Roof and Maria Theresien Strasse in Innsbruck.</li><li>Visit the famous Swarovski Crystal museum and showroom in Wattens.</li><li>Visit the Murano glass showroom in Venice.</li><li>Romantic gondola ride in Venice.</li><li>Guided city tour of Florence.</li><li>See the Leaning Tower of Pisa – one of the wonders of the world.</li><li>Guided city tour of Rome.</li><li>A visit to the Vatican Museum including the Sistine Chapel.</li><li>Professional, friendly, multilingual and experienced Indian Tour Managers travelling with you throughout your tour in Europe.</li><li><b>Visit 09 countries in 15 days:</b> UK, France, Belgium, Netherlands, Germany, Switzerland, Austria, Italy and Vatican city.</li></ul></div><br>						<!--DATA5 EMD--></div>
												<div class="ic bdr" id="data6"><!--DATA6 START-->
						<br />
						~^#^~~^#^~Passengers joining this tour must travel to / from the hub city at their own expense.
The airfare is based on the fare structure existing as on August 31, 2012. Any further increase in the airfare due to an increase in the fuel price, change in Government regulations, taxes, etc., charged by the airline will have to be borne by the passengers.
Thomas Cook will not be held responsible for the same.
Indian Lunches and Dinners and local meals are pre set and a-la carte is not possible.
Breakfast will be continental which includes tea, coffee, cereal, juice, bread and butter.
Indian lunches are vegetarian lunches.
On certain days packed lunch will be provided.
Any damages caused to the hotel rooms / Coach during your stay, shall be payable by the passengers. Thomas Cook will not be liable for the same.
The company shall not accept any liability or responsibility for any damages, loss, baggage loss, theft, injury, accident, death, breakdown or irregularity, which may occur in carrying out the tour arrangement, weather conditions, strikes, war, quarantine and any other cause whatsoever and all such loss or expense must be borne by the passengers.
Insurance policies must be carried while on tour.
The management reserves the right to claim any additional expenses incurred due to delay or changes in schedules of train, aeroplane, bus, ship or other services.
Due to private coaches being forbidden inside the cities of Rome, Florence, Venice, Amsterdam etc, most of your sightseeing will be done by local buses and by foot. The tour manager and the driver will do their best to get you as close to the monuments as possible.
Due to major international events and trade fairs throughout Europe such as Air Show, World Athletic Meet, the Motor Show, Ice Skating Championships etc, the hotels may be blocked out more than two years in advance. In view of this, you may have to stay in hotels further away from the cities and the itineraries may have to be altered / amended.
We also reserve the right to substitute a hotel of similar class if it is deemed advisable or necessary.
The Leaning Tower of Pisa is an 8 storey structure with no lift and 294 slippery marble steps, hence we do not visit from inside.
On certain days the changing of guards may not take place at the Buckingham Palace.
The Eiffel Tower on certain days due to strong wind conditions or being overcrowded may close the third level.
On certain days, due to closure of the Sistine Chapel, St. Peter's basilica etc. the Tour Manager reserves the right to amend the itinerary.
We reserve the right to amend, alter, vary or withdraw any particular departure, excursion advertised.
For the convenience of our passengers, we will sometimes amend the itinerary.
However all the services will remain the same.
There are no refunds for any services i.e. meals, sightseeing etc. not utilized on your tour.
A local representative or a driver may only be there to assist you during your initial part of the tour.
In case you decide to change the date of your return reservation once confirmed the exact amount payable to the airline will be advised once the same is confirmed.
Taxes as applicable.
The images used in this brochure are for representation purpose only.
Tours operated are subject to RBI/GOI regulations. Part of the tour cost will be paid in EURO / CHF out of your BTQ at prevailing rate of exchange.
Please refer to the Booking Form for detailed 'Terms and Conditions'.						<!--DATA6 EMD--></div>
											
					<!--MY TABS END--></div>
					";i:1;s:69:"Book Grand Bargain Tour of Europe - 14 Nights / 15 Days Tour Packages";i:2;s:137:"book grand bargain tour of europe - 14 nights / 15 days tour packages, adventure tour packages, london, italy, vatican city tour packages";i:3;s:168:"Geet & Company offers Grand Bargain Tour of Europe - 14 Nights / 15 Days tour package, budget Adventure tour packages for London, Italy, Vatican City at exciting price.";i:4;s:1902:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "London, Italy, Vatican City"        
		                 },
		      "description": "<b>What Your Tour Price Does Not Include</b><br>
If you wish to travel in advance i.e., before the published departure date as mentioned in the brochure or like to come back on a later date after the tour ends, there will be an additional charge that will be applicable (subject to availability of seats for the given dates & ticket validity) which will be advised to you by our sales staff / travel agent. Kindly note, the deviation will be actioned only 30 days prior to departure date.
In case your tour is not ending in United Kingdom and you wish to return from London or any other city in the United Kingdom, the UK departure tax will be advised on confirmation of the deviation date.
Cost of Basic Travel Quota equivalent to USD 10,000.
Any increase in the airfare charged by the airline on your air ticket (presently calculated as of 31st August 2012 rates).
Taxes as applicable are extra.
The tour cost does not include POE charges and passport charges.
No porterage included.
Any expenses of personal nature such as porterage, laundry expenses, wines, mineral water, food and drink not in the regular menu provided by us, minibar, telephone calls etc.
Tips of any nature i.e. drivers, guides, etc.
Meals other than that what is mentioned in your itinerary.
Cost of excursions, city sightseeing, entrance fees and local guides availed of by the passengers, other than that mentioned in 'What your tour price includes'.
Cost of Lido Show and Jungfraujoch.",
		      "name": "Grand Bargain Tour of Europe",
		      "telephone": "+91-9896771268"
		    }
		    </script>
			";i:5;N;}