a:6:{i:0;s:31445:"				<div class="h1"><h1>Voyage Of Asia - Summer 2016 Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="https://www.grandindiatrip.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="https://www.grandindiatrip.com/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Voyage Of Asia - 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 - Asia</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						8 Nights / 9 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Kuala Lumpur, Singapore</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 99360 Per Person						</td>
						</tr>
												<tr>
						<td class="b p5px dif w125px vat">Special Offer </td>
						<td class="p5px pl0px dif vat">Kuala Lumpur<br />
Singapore<br />
Kuala Lumpur<br />
Panoramic tour - Kuala Lumpur City Tour, Enjoy the Genting Highland with one way cable.<br />
Night Safari Without Dinner (seat In Coach)<br />
Singapore Flyer (during City Tour) (ticket Only)<br />
Universal Studio Entrance [no Meal Coupon] (seat In Coach)<br />
Madame Tussauds Wax Museum Entrance (during Sentosa Tour) (seat In Coach)<br />
Jurong Bird Park (seat In Coach)<br />
Night Safari Without Dinner (seat In Coach) A wild adventure awaits you as you visit the fascinating world of nocturnal creatures at the world's first wildlife park built specifically for night viewing. This premier night zoo is set in 40 hectares of secondary jungle, enhanced by subtle moonglow lighting and houses over 900 animals of 135 exotic species in eight zones recreated to simulate various geographic zones. Experience the thrill of exploring a tropical jungle at night by tram or by foot. The mystery and drama of the tropical jungle comes alive after dusk, and you'll experience a thrilling sense of roaming through the jungle as you travel through the grounds by open tram. You'll pass a large reservoir and weave through habitats specially designed to replicate the natural environment, from the Himalayan foothills to the Southeast Asian rainforest and Indian subcontinent.<br />
<br />
Hotels Info<br />
<br />
City	Hotel Name<br />
Kuala Lumpur	<br />
Pearl International Hotel Or Similar<br />
Onboard The Cruise	<br />
Superstar Gemini Or Similar<br />
Singapore	<br />
Grand Imperial Hotel Or Similar</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Voyage Of Asia - 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="62667"/>
						</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/116993.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/116993.jpg"  width="150" height="150"    alt="Voyage Of Asia - Summer 2016 Tour" title="Voyage Of Asia - Summer 2016 Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					09 Days / 08 Nights<br />
Visit -  MALAYSIA, SINGAPORE<br />
HIGHLIGHTS-<br />
Panoramic city tour of Kuala Lumper's.<br />
Enjoy the Sentosa lslands.<br />
Day excursion to Genting Highlands with one way Cable car.<br />
A scintillating, fun filled holiday extravaganza awaits you! With an itinerary that takes you to Kuala Lumpur and Singapore, this holiday brings to you diverse experiences. Theme parks, city tours, cable car rides, natural wonders, cultural extravaganzas and culinary delights are just some of the experiences that await you. With such varied experiences, you can truly celebrate Asia on this vacation.<br />
<br />
Important Note<br />
Minimum connecting time between international and domestic flights should be 4 and half hours prior to departure.<br />
2 Child without bed - Is an individual under 12 years of age, sharing the room with 2 Full Paying adults and without a bed / cot.<br />
In a room there can be maximum of 3 adults. As a 3rd person in a Triple Room, most hotels use roll away beds or 2 queen size beds and the room size will be the same as a Double Room.<br />
For Two Adults & Two Children (Both Under 12 Years) rooming together, the 1st Child will have to pay "Child with Bed" price and the 2nd Child will pay "Child without Bed" price.<br />
In the event that the group size is less than 20 adult passengers, you will be given an option of travelling on an FIT basis, by paying an additional FIT Supplement. The Tour will be conducted on a seat-in-coach basis for a group strength of 2- 20, with the assistance of a local representative.<br />
Any damage caused to the hotel rooms / coach during your stay, shall be borne by the concerned passengers<br />
The management reserves the right to claim any additional expenses incurred due to delay or changes in schedules of train, airplane, bus, ship or any other services.<br />
On days when certain attractions, sights, monuments, museums, etc. are closed, the Tour Manager reserves the right to amend the Itinerary / cancel the visit<br />
For convenience of our passengers, we will sometimes amend the itinerary. However the services remain unchanged<br />
The right to vary, amends, alters or withdraws 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.<br />
Indian lunches and dinners and local meals are pre set & a-la carte is not possible.<br />
Minimum connecting time cruise should be 2 and half hours prior to departure.<br />
On Cruise a Guest under 18 years of age ("Minor") must be accompanied by a Guest 18 years or older ("Accompany Adult")<br />
Onboard Super Star Gemini will not be allowed to upload liquor from outside, Drinks can only be purchased from the Ship Only<br />
Star Cruises will be collecting a mandatory SGD 300 cash deposit/credit card pre-authorisation to add convenience for bill settlement during the cruise check-out process onboard SuperStar Gemini.<br />
Once an air ticket is issued, date change penalty cost will be applicable. Check with our Sales Officer for the applicable charges<br />
Overseas Travel Insurance for the duration of the tour is included in the tour price. However, any passengers who wish to extend their stay will be required to pay additional charges.<br />
Subject to availability of flights passengers can book their tour directly from their city by paying an additional amount. Please check with respective sales officer at the time of booking.<br />
A part of your tour price will be taken in USD from your LRS as per the RBI / GOI regulations.<br />
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 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.<br />
There are no refunds for any services i.e. meals, sightseeing, etc not utilized on your tour<br />
The tour manager and driver will do their best to get you as close to the monuments as possible, because in some cities coaches are restricted<br />
Additional supplements on account of fuel hikes as and when received would be applicable with immediate effect<br />
Infant of age 6 months or less as on sailing date are strictly not allowed to board the cruise<br />
Passage for Pregnant Woman on cruise will only be before her 24th week of Pregnancy at the time of sailing<br />
Super Star Gemini Cruise -- Ex Singapore (03 Days / 02 Nights) Gratuity Cost for cruise is not inlcuded in the package cost.<br />
The tour will be operated, subject to a minimum of 20 full paying adult passengers travelling together.Kuala Lumpur<br />
Singapore<br />
Kuala Lumpur<br />
Panoramic tour - Kuala Lumpur City Tour, Enjoy the Genting Highland with one way cable.<br />
Night Safari Without Dinner (seat In Coach)<br />
Singapore Flyer (during City Tour) (ticket Only)<br />
Universal Studio Entrance [no Meal Coupon] (seat In Coach)<br />
Madame Tussauds Wax Museum Entrance (during Sentosa Tour) (seat In Coach)<br />
Jurong Bird Park (seat In Coach)<br />
Night Safari Without Dinner (seat In Coach) A wild adventure awaits you as you visit the fascinating world of nocturnal creatures at the world's first wildlife park built specifically for night viewing. This premier night zoo is set in 40 hectares of secondary jungle, enhanced by subtle moonglow lighting and houses over 900 animals of 135 exotic species in eight zones recreated to simulate various geographic zones. Experience the thrill of exploring a tropical jungle at night by tram or by foot. The mystery and drama of the tropical jungle comes alive after dusk, and you'll experience a thrilling sense of roaming through the jungle as you travel through the grounds by open tram. You'll pass a large reservoir and weave through habitats specially designed to replicate the natural environment, from the Himalayan foothills to the Southeast Asian rainforest and Indian subcontinent.<br />
<br />
Hotels Info<br />
<br />
City	Hotel Name<br />
Kuala Lumpur	<br />
Pearl International Hotel Or Similar<br />
Onboard The Cruise	<br />
Superstar Gemini Or Similar<br />
Singapore	<br />
Grand Imperial Hotel Or SimilarOptional & 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 tickets (presently calculated on 01 Jan 2015).<br />
Airline and Hotel surcharges (if applicable) during high / festive season / trade fairs to be paid extra per person.<br />
Cost of extension of validity or deviation of your air ticket.<br />
Any increase in the rate of USD leading to an increase in Tour Cost coming into effect prior to departure. However, the rate of exchange on the given day of payment will apply.a<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 />
Anything not specifically mentioned in 'What Your Tour Price Includes' box.<br />
An additional amount of INR 1,500 is to be compulsorily paid by way of "Secure your Booking Amount".<br />
Baggage handling fee charged by the operating airline for the excess check-in baggage.<br />
Gratuities (To be paid directly on board the cruise)<br />
Govt. Service Tax 4.50% on gross bill effective 1st June 2016.<br />
Passport Charges.<br />
Any increase in visa fees / cost of fuel surcharge on airline tickets, port charges on cruise (presently calculated at 01 Jan 2016)<br />
Airline Reservation Fee (ARF) charges of INR 2500 per person will apply for any deviation to your airline ticket.<br />
Cost of any private transfers taken to move from one place to another instead of coach as per tour itinerary.<br />
Medical test and Premium cost of your Travel tag / Assist with Insurance valid for passengers above 70 years of age.<br />
Any extra expenses incurred for route change, airline change/ date change / accommodation due to any unforeseen circumstances, forced majuire instances, natural calamities, political disturbances, strikes etc.21-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 Kuala Lumpur
								</p>
								<p class="aj">Voyage of Asia" tour. On arrival in Kuala Lumpur, meet our Cox and Kings representative and proceed to the orientation tour of Putrajaya -federal administrative capital of Malaysia, View Putra Lake, Putra Bridge, Seri Perdana Complex. Continue to Kuala Lumpur and check in to the hotel (check in after 1400 Hrs).<br />
KL - as it is popularly called is a bustling city with a skyline endorsed with skyscrapers, domes and minarets.<br />
Overnight in Kuala Lumpur.</p>					
									<p><b>Meals : </b> 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 Kuala Lumpur
								</p>
								<p class="aj">Today, after breakfast, Proceed for a guided panoramic city tour. See the King's Palace, National Monument, National Mosque, Jamek Mosque, Merdeka Square and National Museum. Admire Malaysia's most renowned structure, the world famous Petronas Twin Towers and enjoy a photo stop.<br />
Overnight in Kuala Lumpur</p>					
									<p><b>Meals : </b> Breakfast at the hotel restaurant, Lunch 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> Kuala Lumpur - Genting Highlands - Kuala Lumpur
								</p>
								<p class="aj">Today morning, proceed to Batu caves. The caves are one of the most popular limestone caves and said to be around 400 million years old. Later proceed to Genting Highlands, Malaysia's premier hill resort, With cable car ride (one way).<br />
Overnight in Kuala Lumpur.</p>					
									<p><b>Meals : </b> Breakfast at the hotel Restaurant, Lunch 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> Kuala Lumpur - Onto Singapore
								</p>
								<p class="aj">Today, we proceed to Singapore by coach. (approx 6 hours). Enroute Lunch.<br />
Transfer to Cruise Centre. Embark onto Superstar Gemini cruise. You could entertain yourself with live music at the bandstand, or dance away the night or listen to live music at Galaxy Of The Stars on the cruise.<br />
Overnight on board the cruise.</p>					
									<p><b>Meals : </b> Breakfast at the hotel restaurant, Lunch at an Indian restaurant, Dinner on board the cruise.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 5:</b> On board the cruise
								</p>
								<p class="aj">Day free to view the vast sea and ships around, or explore various activities on board the cruise like swimming, fitness centre, library, karaoke lounge etc.<br />
Overnight on board the cruise.</p>					
									<p><b>Meals : </b> Breakfast, Lunch and Dinner on board the cruise.</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 Singapore
								</p>
								<p class="aj">Disembark from the cruise. and transfer to the hotel.<br />
Rest of the day is at leisure to explore this wonderful and majestic city.<br />
Overnight in Singapore.</p>					
									<p><b>Meals : </b> Breakfast and Lunch on board the cruise, 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> In Singapore
								</p>
								<p class="aj">Today proceed on a guided panoramic city tour driving past the famous landmarks of Singapore- City Hall, Parliament House, Raffles Hotel. Take a photo stop at Singapore's famous symbol - the Merlion and the Esplanade. Onto Mount Faber. Proceed by Cable Car Ride to Sentosa Island, where "Fun happens all the time". Enjoy the Skyline Luge, (once) a fun-filled gravity ride that's safe for all ages. Then board the Skyride Chairlift for a bird's-eye view of Sentosa and Singapore skyline together. Visit Underwater World, home to more than 2500 marine animals, each one as fascinating as the next. At Dolphin Lagoon, watch pink dolphins and Fur Seals in action with their playful activities. Watch "Meet the Dolphins and Fur Seal LIVE!"<br />
Wrap up the evening with the mesmerizing night show by the sea - "Wings of Time". Discover an awe-inspiring display of water, laser and fire effects, weaved together by a tale of friendship and courage that will leave you spell bound. "<br />
You can opt for 4D Adventureland, either Extreme Log Ride or Journey2: The Mysterious Island. You can also opt for Madam Tussauds Wax Museum, including a Boat Ride, and take memorable photos with favourite celebrities. Or opt for Butterfly Park and Insect Kingdom.<br />
Overnight in Singapore</p>					
									<p><b>Meals : </b> Breakfast at the hotel restaurant, Lunch 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 8:</b> In Singapore
								</p>
								<p class="aj">Today day at leisure or opt for Jurong Bird Park, and watch different birds, and see the birds performing at Shows too. Or opt for Night Safari, with Tram Ride, and watch animals in natural habitat!<br />
OR<br />
Or Visit Universal Studios and transform yourself to world of Movie making, cutting-edge rides, and shows based on popular blockbuster films and television series.<br />
Overnight in Singapore.</p>					
									<p><b>Meals : </b> Breakfast at the hotel restaurant, 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 9:</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>					
									<p><b>Meals : </b> Breakfast, either at the hotel or on board your return flight</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>Flights</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>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 tickets (presently calculated on 01 Jan 2015).</li><li>
Airline and Hotel surcharges (if applicable) during high / festive season / trade fairs to be paid extra per person.</li><li>
Cost of extension of validity or deviation of your air ticket.</li><li>
Any increase in the rate of USD leading to an increase in Tour Cost coming into effect prior to departure. However, the rate of exchange on the given day of payment will apply.a</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>
Anything not specifically mentioned in 'What Your Tour Price Includes' box.</li><li>
An additional amount of INR 1,500 is to be compulsorily paid by way of "Secure your Booking Amount".</li><li>
Baggage handling fee charged by the operating airline for the excess check-in baggage.</li><li>
Gratuities (To be paid directly on board the cruise)</li><li>
Govt. Service Tax 4.50% on gross bill effective 1st June 2016.</li><li>
Passport Charges.</li><li>
Any increase in visa fees / cost of fuel surcharge on airline tickets, port charges on cruise (presently calculated at 01 Jan 2016)</li><li>
Airline Reservation Fee (ARF) charges of INR 2500 per person will apply for any deviation to your airline ticket.</li><li>
Cost of any private transfers taken to move from one place to another instead of coach as per tour itinerary.</li><li>
Medical test and Premium cost of your Travel tag / Assist with Insurance valid for passengers above 70 years of age.</li><li>
Any extra expenses incurred for route change, airline change/ date change / accommodation due to any unforeseen circumstances, forced majuire instances, natural calamities, political disturbances, strikes etc.</li></ul><br />
												<p class="large b mb5px dif">Specific Departure Dates :</p>umbai<br />
Delhi<br />
Kolkata<br />
Chennai<br />
June 2016	-	26<br />
July 2016	-	24<br />
August 2016	-	14,28<br />
September 2016	-	11,25<br />
												<p class="large b mb5px dif">Departure Cities with rates :</p>A wild adventure awaits you as you visit the fascinating world of nocturnal creatures at the world's first wildlife park built specifically for night viewing. This premier night zoo is set in 40 hectares of secondary jungle, enhanced by subtle moonglow lighting and houses over 900 animals of 135 exotic species in eight zones recreated to simulate various geographic zones. Experience the thrill of exploring a tropical jungle at night by tram or by foot. The mystery and drama of the tropical jungle comes alive after dusk, and you'll experience a thrilling sense of roaming through the jungle as you travel through the grounds by open tram. You'll pass a large reservoir and weave through habitats specially designed to replicate the natural environment, from the Himalayan foothills to the Southeast Asian rainforest and Indian subcontinent.<br /><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 29th Mar, 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">Tour Price</td>
				<td class="data p5px">Discount Offer</td>
				<td class="data p5px">INR After Discount</td>
			</tr>
			<tr>
				<td class="data p5px">Twin</td>
				<td class="data p5px">INR 1,08,667(USD 515 + INR 71,999)</td>
				<td class="data p5px">INR 10,547</td>
				<td class="data p5px">INR 98,120</td>
			</tr>
			<tr>
				<td class="data p5px">Triple</td>
				<td class="data p5px">INR 1,08,667(USD 515 + INR 71,999)</td>
				<td class="data p5px">INR 10,547</td>
				<td class="data p5px">INR 98,120</td>
			</tr>
			<tr>
				<td class="data p5px">Single</td>
				<td class="data p5px">INR 1,31,127(USD 690 + INR 81,999)</td>
				<td class="data p5px">INR 12,685</td>
				<td class="data p5px">INR 1,18,442</td>
			</tr>
			<tr>
				<td class="data p5px">Child with bed</td>
				<td class="data p5px">INR 95,767(USD 390 + INR 67,999)</td>
				<td class="data p5px">INR 9,335</td>
				<td class="data p5px">INR 86,432</td>
			</tr>
			<tr>
				<td class="data p5px">Child without bed</td>
				<td class="data p5px">INR 88,647(USD 290 + INR 67,999)</td>
				<td class="data p5px">INR 8,685</td>
				<td class="data p5px">INR 79,962</td>
			</tr>
			<tr>
				<td class="data p5px">Infant</td>
				<td class="data p5px">INR 45,000(USD + INR 45,000)</td>
				<td class="data p5px">INR 0</td>
				<td class="data p5px">INR 45,000</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Package Cost Ex - Delhi - Valid from 29th Mar, 2016 to 30th Sep, 2016</p>
    	<div class="otherDetails aj">Package Pre - Post Night Price<br>
Accommodation + ABF	Twin	Triple	Single	Child with bed	Child without bed<br>
Pre Night - Kuala Lumpur - Pearl International Hotel Or Similar	USD 70	USD 70	USD 130	USD 50	USD 40<br>
Post Night - Singapore - Grand Imperial Hotel Or Similar	USD 100	USD 100	USD 170	USD 75	USD 60<br>
<br>
Package Surcharge Price - Valid from 29th Mar, 2016 to 30th Sep, 2016<br>
Twins	Triple	Single	Child with bed	Child without bed	Infant<br>
11 Sep - 11 Sep	USD 125	USD 125	USD 125	USD 125	USD 125	NA<br>
Package AirSurcharge Price<br>
Adult	Child	Infant<br>
Unsecured Reservation Fee INR 3000 per person. <br>
Booking Amount	and Note INR 30000 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">Type</td>
				<td class="data p5px">Tour Price</td>
				<td class="data p5px">Discount Offer</td>
				<td class="data p5px">INR After Discount</td>
			</tr>
			<tr>
				<td class="data p5px">Twin</td>
				<td class="data p5px">INR 1,10,667(USD 515 + INR 73,999)</td>
				<td class="data p5px">INR 10,747</td>
				<td class="data p5px">INR 99,920</td>
			</tr>
			<tr>
				<td class="data p5px">Triple</td>
				<td class="data p5px">INR 1,10,667(USD 515 + INR 73,999)</td>
				<td class="data p5px">INR 10,747</td>
				<td class="data p5px">INR 99,920</td>
			</tr>
			<tr>
				<td class="data p5px">Single</td>
				<td class="data p5px">INR 1,33,127(USD 690 + INR 83,999)</td>
				<td class="data p5px">INR 12,885</td>
				<td class="data p5px">INR 1,20,242</td>
			</tr>
			<tr>
				<td class="data p5px">Child with bed</td>
				<td class="data p5px">INR 1,00,767(USD 390 + INR 72,999)</td>
				<td class="data p5px">INR 9,835</td>
				<td class="data p5px">INR 90,932</td>
			</tr>
			<tr>
				<td class="data p5px">Child without bed</td>
				<td class="data p5px">INR 93,647(USD 290 + INR 72,999)</td>
				<td class="data p5px">INR 9,185</td>
				<td class="data p5px">INR 84,462</td>
			</tr>
			<tr>
				<td class="data p5px">Infant</td>
				<td class="data p5px">INR 45,000(USD + INR 45,000)</td>
				<td class="data p5px">INR 0</td>
				<td class="data p5px">INR 45,000</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Package Optional Excursion</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="data p5px">Place</td>
				<td class="data p5px">Adult</td>
				<td class="data p5px">Child</td>
				<td class="data p5px">Infant</td>
			</tr>
			<tr>
				<td class="data p5px">Night Safari without Dinner (Seat in Coach)</td>
				<td class="data p5px">USD 50</td>
				<td class="data p5px">USD 40</td>
				<td class="data p5px">NA</td>
			</tr>
			<tr>
				<td class="data p5px">Singapore Flyer (During City Tour) (Ticket Only)</td>
				<td class="data p5px">USD 25</td>
				<td class="data p5px">USD 20</td>
				<td class="data p5px">NA</td>
			</tr>
			<tr>
				<td class="data p5px">Universal Studio Entrance [No Meal Coupon] (Seat in Coach)</td>
				<td class="data p5px">USD 80</td>
				<td class="data p5px">USD 65</td>
				<td class="data p5px">NA</td>
			</tr>
			<tr>
				<td class="data p5px">Madame Tussauds Wax Museum Entrance (During Sentosa Tour) (Seat in Coach)</td>
				<td class="data p5px">USD 40</td>
				<td class="data p5px">USD 35</td>
				<td class="data p5px">NA</td>
			</tr>
			<tr>
				<td class="data p5px">Jurong Bird Park (Seat in Coach)</td>
				<td class="data p5px">USD 12</td>
				<td class="data p5px">USD 12</td>
				<td class="data p5px">NA</td>
			</tr>
		</table></div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Voyage Of Asia - 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="62667"/>
						</form>
						</div>
						
						";i:1;s:72:"Book Voyage Of Asia - Summer 2016 Tour - 8 Nights / 9 Days Tour Packages";i:2;s:135:"book voyage of asia - summer 2016 tour - 8 nights / 9 days tour packages, heritage tour packages, kuala lumpur, singapore tour packages";i:3;s:179:"Grand India Tours & Travels offers Voyage Of Asia - Summer 2016 Tour - 8 Nights / 9 Days tour package, budget Heritage tour packages for Kuala Lumpur, Singapore at exciting price.";i:4;s:8505:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Kuala Lumpur, Singapore"        
		                 },
		      "description": "09 Days / 08 Nights
Visit -  MALAYSIA, SINGAPORE
HIGHLIGHTS-
Panoramic city tour of Kuala Lumper's.
Enjoy the Sentosa lslands.
Day excursion to Genting Highlands with one way Cable car.
A scintillating, fun filled holiday extravaganza awaits you! With an itinerary that takes you to Kuala Lumpur and Singapore, this holiday brings to you diverse experiences. Theme parks, city tours, cable car rides, natural wonders, cultural extravaganzas and culinary delights are just some of the experiences that await you. With such varied experiences, you can truly celebrate Asia on this vacation.

Important Note
Minimum connecting time between international and domestic flights should be 4 and half hours prior to departure.
2 Child without bed - Is an individual under 12 years of age, sharing the room with 2 Full Paying adults and without a bed / cot.
In a room there can be maximum of 3 adults. As a 3rd person in a Triple Room, most hotels use roll away beds or 2 queen size beds and the room size will be the same as a Double Room.
For Two Adults & Two Children (Both Under 12 Years) rooming together, the 1st Child will have to pay "Child with Bed" price and the 2nd Child will pay "Child without Bed" price.
In the event that the group size is less than 20 adult passengers, you will be given an option of travelling on an FIT basis, by paying an additional FIT Supplement. The Tour will be conducted on a seat-in-coach basis for a group strength of 2- 20, with the assistance of a local representative.
Any damage caused to the hotel rooms / coach during your stay, shall be borne by the concerned passengers
The management reserves the right to claim any additional expenses incurred due to delay or changes in schedules of train, airplane, bus, ship or any other services.
On days when certain attractions, sights, monuments, museums, etc. are closed, the Tour Manager reserves the right to amend the Itinerary / cancel the visit
For convenience of our passengers, we will sometimes amend the itinerary. However the services remain unchanged
The right to vary, amends, alters or withdraws 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.
Indian lunches and dinners and local meals are pre set & a-la carte is not possible.
Minimum connecting time cruise should be 2 and half hours prior to departure.
On Cruise a Guest under 18 years of age ("Minor") must be accompanied by a Guest 18 years or older ("Accompany Adult")
Onboard Super Star Gemini will not be allowed to upload liquor from outside, Drinks can only be purchased from the Ship Only
Star Cruises will be collecting a mandatory SGD 300 cash deposit/credit card pre-authorisation to add convenience for bill settlement during the cruise check-out process onboard SuperStar Gemini.
Once an air ticket is issued, date change penalty cost will be applicable. Check with our Sales Officer for the applicable charges
Overseas Travel Insurance for the duration of the tour is included in the tour price. However, any passengers who wish to extend their stay will be required to pay additional charges.
Subject to availability of flights passengers can book their tour directly from their city by paying an additional amount. Please check with respective sales officer at the time of booking.
A part of your tour price will be taken in USD from your LRS as per the RBI / GOI regulations.
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 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.
There are no refunds for any services i.e. meals, sightseeing, etc not utilized on your tour
The tour manager and driver will do their best to get you as close to the monuments as possible, because in some cities coaches are restricted
Additional supplements on account of fuel hikes as and when received would be applicable with immediate effect
Infant of age 6 months or less as on sailing date are strictly not allowed to board the cruise
Passage for Pregnant Woman on cruise will only be before her 24th week of Pregnancy at the time of sailing
Super Star Gemini Cruise -- Ex Singapore (03 Days / 02 Nights) Gratuity Cost for cruise is not inlcuded in the package cost.
The tour will be operated, subject to a minimum of 20 full paying adult passengers travelling together.Kuala Lumpur
Singapore
Kuala Lumpur
Panoramic tour - Kuala Lumpur City Tour, Enjoy the Genting Highland with one way cable.
Night Safari Without Dinner (seat In Coach)
Singapore Flyer (during City Tour) (ticket Only)
Universal Studio Entrance [no Meal Coupon] (seat In Coach)
Madame Tussauds Wax Museum Entrance (during Sentosa Tour) (seat In Coach)
Jurong Bird Park (seat In Coach)
Night Safari Without Dinner (seat In Coach) A wild adventure awaits you as you visit the fascinating world of nocturnal creatures at the world's first wildlife park built specifically for night viewing. This premier night zoo is set in 40 hectares of secondary jungle, enhanced by subtle moonglow lighting and houses over 900 animals of 135 exotic species in eight zones recreated to simulate various geographic zones. Experience the thrill of exploring a tropical jungle at night by tram or by foot. The mystery and drama of the tropical jungle comes alive after dusk, and you'll experience a thrilling sense of roaming through the jungle as you travel through the grounds by open tram. You'll pass a large reservoir and weave through habitats specially designed to replicate the natural environment, from the Himalayan foothills to the Southeast Asian rainforest and Indian subcontinent.

Hotels Info

City	Hotel Name
Kuala Lumpur	
Pearl International Hotel Or Similar
Onboard The Cruise	
Superstar Gemini Or Similar
Singapore	
Grand Imperial Hotel Or SimilarOptional & 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 tickets (presently calculated on 01 Jan 2015).
Airline and Hotel surcharges (if applicable) during high / festive season / trade fairs to be paid extra per person.
Cost of extension of validity or deviation of your air ticket.
Any increase in the rate of USD leading to an increase in Tour Cost coming into effect prior to departure. However, the rate of exchange on the given day of payment will apply.a
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.
Anything not specifically mentioned in 'What Your Tour Price Includes' box.
An additional amount of INR 1,500 is to be compulsorily paid by way of "Secure your Booking Amount".
Baggage handling fee charged by the operating airline for the excess check-in baggage.
Gratuities (To be paid directly on board the cruise)
Govt. Service Tax 4.50% on gross bill effective 1st June 2016.
Passport Charges.
Any increase in visa fees / cost of fuel surcharge on airline tickets, port charges on cruise (presently calculated at 01 Jan 2016)
Airline Reservation Fee (ARF) charges of INR 2500 per person will apply for any deviation to your airline ticket.
Cost of any private transfers taken to move from one place to another instead of coach as per tour itinerary.
Medical test and Premium cost of your Travel tag / Assist with Insurance valid for passengers above 70 years of age.
Any extra expenses incurred for route change, airline change/ date change / accommodation due to any unforeseen circumstances, forced majuire instances, natural calamities, political disturbances, strikes etc.21-0630-09",
		      "name": "Voyage Of Asia - Summer 2016 Tour",
		      "telephone": "+91-9415285186"
		    }
		    </script>
			";i:5;N;}