a:6:{i:0;s:23924:"				<div class="h1"><h1>Eastern Whirl - 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>Eastern Whirl - 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">Budapest, Bratislava, Prague, Vienna</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 81834 Per Person						</td>
						</tr>
												<tr>
						<td class="b p5px dif w125px vat">Special Offer </td>
						<td class="p5px pl0px dif vat">Meet your expert local guide and proceed for a tour of Bratislava the capital, the most beautiful and largest city of Slovakia. This city has become one of the most famous tourist travel-spots, offering beautiful scenery, pleasant climate all year, excellent shopping malls, and welcomes tourists with an open heart and hospitality.<br />
<br />
Bratislava, fuels the country's IT, finance, tourism and service industries. Museums, preserved churches, reconstructed mansions and palaces attract global visitors that generate profit for the tourism sector. Drive past the Presidential Palace and take a leisurely walk through the old town stopping at the medieval Town hall.<br />
<br />
Then continue your drive to Budapest where on arrival you will have dinner and then check into your hotel.<br />
Overnight in Budapest.<br />
Dinner at an Indian restaurant.</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="Eastern Whirl - 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="62289"/>
						</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/116248.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/116248.jpg"  width="150" height="150"    alt="Eastern Whirl - Summer 2016 Tour" title="Eastern Whirl - Summer 2016 Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Eastern whirl may seem mysterious to many travelers which only adds to its charm. Discover a number of remarkable places and cities with astonishing beauty and historic significance. For the casual tourists, the Alps are often associated with countries like Austria and the north of Italy. But the beauty of the most famous European mountain chain extends even further to the east.<br />
<br />
All 'must see' sights covered<br />
Easy Travelling, 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 />
Fabulous Optionals, Great Prices - You can design the holidays of your choice from the plethora of options before you.<br />
Budapest from the Fisherman's Bastion.<br />
Musical city of Vienna.<br />
Golden City - Prague.<br />
The Sedlec Ossuary - Bone Church.<br />
Cesky Krumlov - UNESCO world cultural heritage site.Meet your expert local guide and proceed for a tour of Bratislava the capital, the most beautiful and largest city of Slovakia. This city has become one of the most famous tourist travel-spots, offering beautiful scenery, pleasant climate all year, excellent shopping malls, and welcomes tourists with an open heart and hospitality.<br />
<br />
Bratislava, fuels the country's IT, finance, tourism and service industries. Museums, preserved churches, reconstructed mansions and palaces attract global visitors that generate profit for the tourism sector. Drive past the Presidential Palace and take a leisurely walk through the old town stopping at the medieval Town hall.<br />
<br />
Then continue your drive to Budapest where on arrival you will have dinner and then check into your hotel.<br />
Overnight in Budapest.<br />
Dinner at an Indian restaurant.An additional amount of INR 1500 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 Bratislava
								</p>
								<p class="aj">Meet your expert local guide and proceed for a tour of Bratislava the capital, the most beautiful and largest city of Slovakia. This city has become one of the most famous tourist travel-spots, offering beautiful scenery, pleasant climate all year, excellent shopping malls, and welcomes tourists with an open heart and hospitality.<br />
<br />
Bratislava, fuels the country's IT, finance, tourism and service industries. Museums, preserved churches, reconstructed mansions and palaces attract global visitors that generate profit for the tourism sector. Drive past the Presidential Palace and take a leisurely walk through the old town stopping at the medieval Town hall.<br />
<br />
Then continue your drive to Budapest where on arrival you will have dinner and then check into your hotel.<br />
Overnight in Budapest.<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 Budapest
								</p>
								<p class="aj">Today enjoy a guided city tour. Budapest is a graceful capital along the banks of the majestic Danube. Walk along the Fisherman's bastion for superb views of St. Stephen's cathedral. Hero's square the Danube embankment and the Chain bridge. Surprising sights and unexpected delights await!<br />
<br />
Drive by the Parliament, cross the Danube on industrial and business part of the town past the enormous Heroes Square, the beautiful Chain Bridge that connects the cities of Buda and Pest, the statue of St. Stephen and the seven turrets. Discover the residential area of Strahov.<br />
Return into your hotel after dinner.<br />
Overnight in Budapest.<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 Vienna
								</p>
								<p class="aj">Today set your watches back 100 years as you continue your drive to the musical city of Vienna.<br />
You will be taken on a guided panoramic city tour of Vienna, which will inspire you by its charm and astonish you by the splendorous buildings of a time that is in a way still present.<br />
Commence with a photo stop to the Schoenbrunn Palace a UNESCO world cultural heritage site. Enjoy photographic opportunities as you drive around the ring and pass famous landmarks like the great State Opera House, St. Charles Church (photo stop), the Imperial Palace (Hofburg) (photo stop), the Belvedere (photo stop), the Parliament and the Town Hall among others offering an insight into the culture and history of the city and of the Habsburg dynasty.<br />
Spend a few hours visiting the popular Vienna Prater - an amusement park. Enjoy the various rides on your own. Take a walk in the beautiful woodlands. Not to be missed is the popular Ferris Wheel.<br />
Late this evening after dinner check into your hotel.<br />
Overnight in Vienna.<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> Onto Prague
								</p>
								<p class="aj">Leave for Prague, enroute stop at Cesky Krumlov which is a city in the South Bohemia region of the Czech Republic. It's bisected by the Vltava River, and dominated by its 13th-century castle. The castle has Gothic, Renaissance and baroque elements, an 11-hectare garden and an original 17th-century baroque theater. There are panoramic views of the old town and the river. After some free time continue your drive to Prague where on arrival you will be checked into your hotel.<br />
Later after dinner return to the hotel.<br />
Overnight in Prague.<br />
Breakfast in 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> In Prague
								</p>
								<p class="aj">Enjoy a guided highlight walking city tour of Prague. Commence your exploration of this city admiring the grandeur of the Royal Palace that used to be the seat of the Bohemian princes. Get acquainted with Prague's major sights like the picturesque Charles Bridge and the Old Town Square. Continuing in the Old town, finish your tour at the square with the famous Astronomical Clock.<br />
Bohemian Crystal is world famous. Time for a spot of shopping, After dinner return to your hotel.<br />
Overnight in Prague.<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 6:</b> In Prague
								</p>
								<p class="aj">Today you have a free morning to pursue individual activities.<br />
This afternoon drive to visit the Bone Church also called The Sedlec Ossuary, a small Roman Catholic chapel, located beneath the Cemetery Church of All Saints in Sedlec, a suburb of Kutna Hora. It is one of twelve World Heritage Sites in the Czech Republic. The Ossuary is estimated to contain the skeletons of between 40,000 and 70,000 people, whose bones have in many cases been artistically arranged to form decorations and furnishings for the chapel. The ossuary is among the most visited tourist attractions. An enormous chandelier of bones, which contains at least one of every bone in the human body, hangs from the center of the nave with garlands of skulls draping the vault.<br />
After dinner, return to your hotel.<br />
Overnight in Prague.<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! Your tour ends with guests departing on individual schedules for the airport.</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 1500 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>Mumbai<br />
June 2016	-18<br />
												<p class="large b mb5px dif">Departure Cities with rates :</p>City - Hotel Name
Budapest - Star City Hotel Or Similar
Vienna - Austria Trend Hotel Favorita Or Similar
Prague - Duo Praha Or Similar<br /><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>~^#^~~^#^~<p><strong>Important Note</strong>

<ul>
	<li>A part of your tour price will be taken in Euros from your BTQ as per the RBI / GOI regulations.</li>
	<li>Child without bed - Is an individual under 12 years of age, sharing the room with 2 full paying adults and without a bed / cot.</li>
	<li>For Two Adults &amp; Two Children (Both under 12 Years) rooming together, the 1st child will have to pay &quot;Child with Bed&quot; price and the 2nd Child will pay &quot;Child without Bed&quot; price.</li>
	<li>Maximum 3 adults allowed per room. As a Third person in a Triple room, most of the hotels used roll-away beds and room size may be the same as the Double room.</li>
	<li>Additional supplements on account of fuel hikes as and when received would be applicable with immediate effect.</li>
	<li>Once an air ticket is issued, date change penalty will be applicable. Check with our Sales Officer for the applicable charges.</li>
	<li>The right to vary, amend, alter or withdraw any particular itinerary, departure or excursion rests entirely with the company. Due to demand of a particular airline the in / out points may change. Services however, will remain unchanged.</li>
	<li>Indian dinners and local meals are pre set &amp; a-la carte is not possible.</li>
	<li>Any damage caused to the hotel rooms / coach during your stay, shall be borne by the concerned passengers.</li>
	<li>The company shall not accept any liability or responsibility for any damages, loss of baggage, loss, injury, accident, death, breakdown or irregularity, which may occur in carrying out the tour arrangements due to weather conditions, strikes, war, threat of war, quarantine or any other cause whatsoever and all such loss or expenses must be borne by the passengers.</li>
	<li>The management reserves the right to claim any additional expenses incurred due to delay or changes in schedules of train, aeroplane, bus, ship or any other services.</li>
	<li>This tour may be run with an altered flow due to operational reasons.</li>
	<li>The Tour Manager and the driver will do their best to get you as close to the monuments as possible, because in some cities coaches are restricted.</li>
	<li>Eastern Whirl itinerary often operates more than one coach per departure &amp; on certain departures will operate in reverse direction.</li>
	<li>On days when certain attractions, sights, monuments, museums, etc. are closed, the Tour Manager reserves the right to amend the Itinerary / cancel the visit.</li>
	<li>There are no refunds for any services i.e. meals, sightseeing, etc not utilized on your tour.</li>
	<li>For the convenience of our passengers, we will sometimes amend the itinerary. However the services will remain unchanged.</li>
</ul>						
    	<p class="h dif xlarge b mb5px">Eastern Whirl - Summer 2016</p>
    	<div class="otherDetails aj">Price- All rates are based on currents ROE EUR 1 = INR 79.6. The rate of exchange prevailing on the day of payment will apply.<br>
Ex - Mumbai - Valid from 19th Jan, 2016 to 30th Sep, 2016</div><br>
		<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 82,834(EUR 399 + INR 51,074)</td>
				<td class="data p5px">INR 1,000</td>
				<td class="data p5px">INR 81,834</td>
			</tr>
			<tr>
				<td class="data p5px">Triple</td>
				<td class="data p5px">INR 82,834(EUR 399 + INR 51,074)</td>
				<td class="data p5px">INR 1,000</td>
				<td class="data p5px">INR 81,834</td>
			</tr>
			<tr>
				<td class="data p5px">Single</td>
				<td class="data p5px">INR 1,12,684(EUR 774 + INR 51,074)</td>
				<td class="data p5px">INR 1,000</td>
				<td class="data p5px">INR 1,11,684</td>
			</tr>
			<tr>
				<td class="data p5px">Child with bed</td>
				<td class="data p5px">INR 75,058(EUR 339 + INR 48,074)</td>
				<td class="data p5px">INR 1,000</td>
				<td class="data p5px">INR 74,058</td>
			</tr>
			<tr>
				<td class="data p5px">Child without bed</td>
				<td class="data p5px">INR 71,874(EUR 299 + INR 48,074)</td>
				<td class="data p5px">INR 1,000</td>
				<td class="data p5px">INR 70,874</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 Pre Night Price</p>
    	<div class="otherDetails aj">Package Air Surcharge Price<br>
Adult, Child, Infant<br>
<br>
Reservation Fee INR 3000 per person. <br>
Booking Amount and Note INR 20000 per person ( Interest free and non - refundable) adjusted against the tour cost</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="data p5px">Accommodation + ABF</td>
				<td class="data p5px">Pre Night - Bratislava - Holiday Inn Bratislava Or Similar</td>
			</tr>
			<tr>
				<td class="data p5px">Twin</td>
				<td class="data p5px">EUR 85</td>
			</tr>
			<tr>
				<td class="data p5px">Triple</td>
				<td class="data p5px">EUR 85</td>
			</tr>
			<tr>
				<td class="data p5px">Single</td>
				<td class="data p5px">EUR 120</td>
			</tr>
			<tr>
				<td class="data p5px">Child with bed</td>
				<td class="data p5px">EUR 75</td>
			</tr>
			<tr>
				<td class="data p5px">Child without bed</td>
				<td class="data p5px">EUR 50</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="Eastern Whirl - 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="62289"/>
						</form>
						</div>
						
						";i:1;s:71:"Book Eastern Whirl - Summer 2016 Tour - 6 Nights / 7 Days Tour Packages";i:2;s:147:"book eastern whirl - summer 2016 tour - 6 nights / 7 days tour packages, heritage tour packages, budapest, bratislava, prague, vienna tour packages";i:3;s:191:"Grand India Tours & Travels offers Eastern Whirl - Summer 2016 Tour - 6 Nights / 7 Days tour package, budget Heritage tour packages for Budapest, Bratislava, Prague, Vienna at exciting price.";i:4;s:4014:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Budapest, Bratislava, Prague, Vienna"        
		                 },
		      "description": "Eastern whirl may seem mysterious to many travelers which only adds to its charm. Discover a number of remarkable places and cities with astonishing beauty and historic significance. For the casual tourists, the Alps are often associated with countries like Austria and the north of Italy. But the beauty of the most famous European mountain chain extends even further to the east.

All 'must see' sights covered
Easy Travelling, 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!
Fabulous Optionals, Great Prices - You can design the holidays of your choice from the plethora of options before you.
Budapest from the Fisherman's Bastion.
Musical city of Vienna.
Golden City - Prague.
The Sedlec Ossuary - Bone Church.
Cesky Krumlov - UNESCO world cultural heritage site.Meet your expert local guide and proceed for a tour of Bratislava the capital, the most beautiful and largest city of Slovakia. This city has become one of the most famous tourist travel-spots, offering beautiful scenery, pleasant climate all year, excellent shopping malls, and welcomes tourists with an open heart and hospitality.

Bratislava, fuels the country's IT, finance, tourism and service industries. Museums, preserved churches, reconstructed mansions and palaces attract global visitors that generate profit for the tourism sector. Drive past the Presidential Palace and take a leisurely walk through the old town stopping at the medieval Town hall.

Then continue your drive to Budapest where on arrival you will have dinner and then check into your hotel.
Overnight in Budapest.
Dinner at an Indian restaurant.An additional amount of INR 1500 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": "Eastern Whirl - Summer 2016 Tour",
		      "telephone": "+91-9415285186"
		    }
		    </script>
			";i:5;N;}