a:6:{i:0;s:83377:"						<section class="headBg theme2 ">
						<div class="wrap">
						<div class="page-title-inner fo"> 
						<div class="h1"><h1>Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)</h1></div>
						<p class="breadcrumb ar uu small"><a href="https://www.sbsjonline.co.in/" title="Home">Home</a>
						
													<b class="ffv p2px">&rsaquo;</b><a href="https://www.sbsjonline.co.in/tour-packages.htm" title="Tour Packages">Tour Packages</a>
								
						<b class="ffv p2px">&rsaquo;</b> Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)</p>
						</div>
						</div>
						</section>
										<section id="middle" class="propDtls">
				<div class="wrap packages" id="bodyFormatNT">
								
				<div class="row1 dt columns12"><!--MIDDLE ROW1 STARTS-->
				<div class="col-1 wideColumn ip ls"><!--MIDDLE ROW1 COL-2 STARTS-->				
								
						<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">
					<div class="h1"><h1>Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)</h1></div>
											<p class="mb5px"><b>Duration :</b> 
						5 Nights / 6 Days 
						</p>
												<p class="mb5px"><b>Destination Covered :</b> Port Blair, Havelock, Genting, Moga</p>
												<p class="mb5px"><b>Tour Themes :</b> Beach and Islands, Sail Boats, Boat Safari</p>
												<p class="mb5px"><b>Starting From :</b> 
						INR 10335 Per Person						</p>
											
					<br />
					<p>
					<form class="inquiry-form" name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.sbsjonline.co.in/enquiry-form-10028.htm">
					<input type="hidden" name="subject" value="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n) - Tour Package"/>
					<input type="hidden" name="allocate_type" value="tour"/>							
					<input type="hidden" name="pkg_slno" value="198084"/>
					</form>
					<a href="javascript:void(0);" class="submit-inquiry buttonBig p10px20px c5px b large dib">Book Your Tour</a>
					
										</p>
										</td>
											<td class="p10px vat ttwDtls-img lh0">
						<div class="">
						<ul class="bxslider11 fx-height" style="margin:0px;padding:0px;">
															<li class="pr"><div>	         
									<div class="slide-fixImag"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317304.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317304.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></div></div></li>
																		<li class="pr"><div>	         
									<div class="slide-fixImag"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317313.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317313.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></div></div></li>
																		<li class="pr"><div>	         
									<div class="slide-fixImag"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317312.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317312.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></div></div></li>
																		<li class="pr"><div>	         
									<div class="slide-fixImag"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317311.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317311.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></div></div></li>
																		<li class="pr"><div>	         
									<div class="slide-fixImag"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317310.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317310.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></div></div></li>
																		<li class="pr"><div>	         
									<div class="slide-fixImag"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317309.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317309.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></div></div></li>
																		<li class="pr"><div>	         
									<div class="slide-fixImag"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317308.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317308.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></div></div></li>
																		<li class="pr"><div>	         
									<div class="slide-fixImag"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317307.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317307.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></div></div></li>
																		<li class="pr"><div>	         
									<div class="slide-fixImag"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317306.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317306.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></div></div></li>
																		<li class="pr"><div>	         
									<div class="slide-fixImag"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317305.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317305.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></div></div></li>
																		<li class="pr"><div>	         
									<div class="slide-fixImag"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317314.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317314.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></div></div></li>
															</ul>
						<script>			
						 $('.bxslider11').bxSlider({
							 mode:'horizontal',
							 auto: true,
							 autoControls: false,
							 stopAutoOnClick: true,		 
							 //controls:false,
							 slideWidth: 350,
							 maxSlides: 1,
							 pager: false,
							 infiniteLoop: false,
							 //pagerCustom:'.bx-pager11'
						  });
						</script>
						</div>
						</td>
											</tr>
					</table>
					</div>
											<div class="mt7px dif small">* Mentioned prices may vary depending upon date of travel, hotel availability, surge pricing and seasonal rush.</div>
														<div class="data mt20px p15px">            
								<div class="mb7px"> 
								<div class="b xlarge mb10px dib"><h2>Port Blair, Havelock and Genting Tour Overview</h2></div>
								</div>
													
								*03 Nights accommodation in Port Blair.<br />
*01 Nights accommodation in Havelock.<br />
*01 Nights accommodation in Neil Island.<br />
*Daily breakfast at the hotel.<br />
*A/C Car for All Package for Sightseeing and excursions as per our brochure itinerary.<br />
*Meal plan as per you choose.<br />
*5.00 % Government service tax ( extra).								</div>
																<div class="headHr mt20px">
					            <div class="p7px b pl10px xlarge"><h2>Port Blair, Havelock and Genting Tour Itinerary</h2></div>
					            </div>
					            
										<div class="data">
										<table class="w100 formTable bdr0 imgWidth">
										<tr>
										<td class="p10px vat">
										<div class="b large mb5px"><b class="dif">Day 1:</b> <h3>Arrival Port Blair + Half Day Local SS (Local Sightseeing point closed on Monday & on all Govt. holidays)</h3>
										</div>
										<p class="aj">You arrive to Port Blair, our escorts in the airport pick receive you there and then after a short introduction will take you to your first booked hotel, after check-in and once you are done with you lunch & refreshment, we will take a tour to the historic cellular jail which will be followed by the light and sound show. <br />
(The history & migration to these archipelago revolves around this monumental architecture , once you finish taking the tour just after a gap of half an<br />
hour , you will witness the light & sound show , like any  other light & sound it’s a narration of the story of the jail through light & sound )<br />
Day end here back to the hotel.</p>
										</td>
											<td class="p10px vat imgWidth200 w200px lh0">
											<div class="demo-wrap">
											<ul class="lsn m0px p0px" >
														<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w200px h200px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317309.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317309.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></p></div></li>
											</ul>
											</div>
											</td>
										</tr>
										</table>					
										</div>
										<div class="data">
										<table class="w100 formTable bdr0 imgWidth">
										<tr>
										<td class="p10px vat">
										<div class="b large mb5px"><b class="dif">Day 2:</b> <h3>Excursion North Bay (Coral Island), Ross Island & Back (Carry Changing Cloth, water & dry food)</h3>
										</div>
										<p class="aj">After breakfast we will set out on a Sea Safari, we will reach the water sports complex from here we will take a luxury motor sail and explore the famous islands of North Bay coral island & the historic Ross Island, experience the fun of cruising and feel the joy of sailing through small big Island and discover the blue ocean and with the on board crew and activity experts who will there to assist you. Upon arrival back to the Port our escorts will arrange necessary<br />
transfers back to the respective hotel.</p>
										</td>
											<td class="p10px vat imgWidth200 w200px lh0">
											<div class="demo-wrap">
											<ul class="lsn m0px p0px" >
														<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w200px h200px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317310.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317310.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></p></div></li>
											</ul>
											</div>
											</td>
										</tr>
										</table>					
										</div>
										<div class="data">
										<table class="w100 formTable bdr0 imgWidth">
										<tr>
										<td class="p10px vat">
										<div class="b large mb5px"><b class="dif">Day 3:</b> <h3>Port Blair to Havelock Island</h3>
										</div>
										<p class="aj">We start the day a bit early today as we need to embark for Havelock Island , the cruise depart at around 0830 hours so we have to report an hour early . Take a quick breakfast and head to Havelock Island the total journey time is around 1 and 1/2 hour by sea. Again once to reach in the island meet our escorts who will be standing outside the harbor restricted area with a name tag. Along with them proceed to your respective hotel and then plan you day, probably<br />
post lunch for Radhanagar beach. You can enjoy the beach as well as the sun set, which i guess is the best you can see. <br />
(Boat transfers are subjected to change as per the availability of tickets and weather conditions).</p>
										</td>
											<td class="p10px vat imgWidth200 w200px lh0">
											<div class="demo-wrap">
											<ul class="lsn m0px p0px" >
														<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w200px h200px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317311.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317311.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></p></div></li>
											</ul>
											</div>
											</td>
										</tr>
										</table>					
										</div>
										<div class="data">
										<table class="w100 formTable bdr0 imgWidth">
										<tr>
										<td class="p10px vat">
										<div class="b large mb5px"><b class="dif">Day 4:</b> <h3>Havelock Island to Neil Island</h3>
										</div>
										<p class="aj">We will check-out the resort as per the schedule timing which is generally in the morning 0900 hours. And then proceed to board the cruise back to Neil Island. Once you arrive in Neil you will meet our escorts outside the exit area, check-in to hotel, finish lunch and then proceed to an excursion to Island visit all the beaches around the Island, night stay at Neil Island.<br />
(While leaving from Port Blair to Havelock island probably you can leave your bigger luggage in port Blair , hotels in Port Blair provide clock room and take only two days cloths and necessary materials to Havelock island, by this way you can avoid the hassle of carrying it inside the harbor area , which is restricted place like the airport and do not have trolley facility).</p>
										</td>
											<td class="p10px vat imgWidth200 w200px lh0">
											<div class="demo-wrap">
											<ul class="lsn m0px p0px" >
														<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w200px h200px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317312.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317312.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></p></div></li>
											</ul>
											</div>
											</td>
										</tr>
										</table>					
										</div>
										<div class="data">
										<table class="w100 formTable bdr0 imgWidth">
										<tr>
										<td class="p10px vat">
										<div class="b large mb5px"><b class="dif">Day 5:</b> <h3>Neil Island To Port Blair (57 Kms)</h3>
										</div>
										<p class="aj">After breakfast proceed to visit Sitapur Beach – One finest beach in this island , there after visit Lakhimpur beach , next to visit Beautiful Bharatpur beach – the ideal place for swimming , After visit drop at Jetty to catch the return boat for Port Blair , on Return to port blair back to your hotel evening free for own activity, Overnight stay at hotel.</p>
										</td>
											<td class="p10px vat imgWidth200 w200px lh0">
											<div class="demo-wrap">
											<ul class="lsn m0px p0px" >
														<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w200px h200px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317313.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317313.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></p></div></li>
											</ul>
											</div>
											</td>
										</tr>
										</table>					
										</div>
										<div class="data">
										<table class="w100 formTable bdr0 imgWidth">
										<tr>
										<td class="p10px vat">
										<div class="b large mb5px"><b class="dif">Day 6:</b> <h3>Departure from Port Blair</h3>
										</div>
										<p class="aj">Morning free for packing & personal activities, on time 08:00am check out from the hotel & on time transfer to Airport.<br />
Tour Ends.</p>
										</td>
											<td class="p10px vat imgWidth200 w200px lh0">
											<div class="demo-wrap">
											<ul class="lsn m0px p0px" >
														<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w200px h200px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_15/434226/317314.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317314.jpg"  height="150"  width="150"    alt="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" title="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)" /></a></p></div></li>
											</ul>
											</div>
											</td>
										</tr>
										</table>					
										</div>								<br />
															<div class="b xlarge mb10px dib"><h2>More Details about Port Blair, Havelock and Genting Tour</h2></div>
															<div class="data mt20px p15px">
								<div class="mb7px"> 
								<p class="b xlarge mb10px dib">Inclusions</p>
								</div>
												
								<ul>
																			<li>CP (Room + Breakfast)</li>
																				<li>Assistance on Arrival</li><li>
Accommodation at above mentioned Hotels or Similar on twin / double sharing in base category rooms basis.</li><li>
Daily Buffet/ fixed Menu Breakfast</li><li>
A/C Car for All Package for Sightseeing and excursions as per itinerary. Point to point not at disposal. Non-A/C vehicle at Havelock & Neil Island.</li><li>
Entrance fees in Port Blair SS</li><li>
NAC Motor Boat Tickets for Ross Island & North Bay Island.</li><li>
Boat Charges for Havelock Island & Neil Island transfer by Luxury Boat. (Green Ocean & Makruzz )</li><li>
All Taxes Except GST.</li>
																	</ul>
								</div>
																<div class="data mt20px p15px">
								<div class="mb7px"> 
								<p class="b xlarge mb10px dib">Exclusions</p>
								</div>
								
								<ul><li>Air fare.</li><li>
Any meals other than those specified in ‘Cost Includes’.</li><li>
Expenses of personal nature such as tips, telephone</li><li>
calls, laundry, liquor etc.</li><li>
Any other item not specified in ‘cost includes’.</li><li>
5.00 % Government service tax.</li><li>
Guide & Any Sports Activities Charges during sightseeing.</li></ul>
								</div>
																<div class="data mt20px p15px">            
								<div class="mb7px"> 
								<p class="b xlarge mb10px dib">Rate Card</p>
								</div>
								
    	<p class="h dif xlarge b mb5px">Cost according to the rooms package ( Per Person)</p>
    	<div class="otherDetails aj">Hotel details.</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Cost Per Person (Breakfast + Dinner)</td>
				<td class="headHr p5px b">2 Pax Minimum Allowed</td>
				<td class="headHr p5px b">4 Pax Minimum</td>
				<td class="headHr p5px b">6 Pax Minimum</td>
				<td class="headHr p5px b">Extra Bed</td>
				<td class="headHr p5px b">Child No Bed</td>
			</tr>
			<tr>
				<td class="headVr p5px">DELUXE</td>
				<td class="data p5px">12090/-</td>
				<td class="data p5px">10855/-</td>
				<td class="data p5px">10335/-</td>
				<td class="data p5px">6695/</td>
				<td class="data p5px">5460/-</td>
			</tr>
			<tr>
				<td class="headVr p5px">SUPERIOR</td>
				<td class="data p5px">14560/-</td>
				<td class="data p5px">13390/-</td>
				<td class="data p5px">12870/-</td>
				<td class="data p5px">8580/-</td>
				<td class="data p5px">6110/-</td>
			</tr>
			<tr>
				<td class="headVr p5px">LUXURY</td>
				<td class="data p5px">16900/-</td>
				<td class="data p5px">15665/-</td>
				<td class="data p5px">15145/-</td>
				<td class="data p5px">10855/-</td>
				<td class="data p5px">8775/-</td>
			</tr>
			<tr>
				<td class="headVr p5px">PREMIUM</td>
				<td class="data p5px">22490/-</td>
				<td class="data p5px">20995/-</td>
				<td class="data p5px">20540/-</td>
				<td class="data p5px">14690/-</td>
				<td class="data p5px">10920/-</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">ACCOMMODATION</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">DESTINATIONS</td>
				<td class="headHr p5px b">PREMIUM</td>
				<td class="headHr p5px b">LUXURY</td>
				<td class="headHr p5px b">SUPERIOR</td>
				<td class="headHr p5px b">DELUXE</td>
			</tr>
			<tr>
				<td class="headVr p5px">Port Blair</td>
				<td class="data p5px">Sarovar Portico/ Similar</td>
				<td class="data p5px">J Hotel /TSG Emerald View/ Similar</td>
				<td class="data p5px">Aparupa Ambienec / Haywizz / Similar</td>
				<td class="data p5px">Hotel Shreesh/ / Similar</td>
			</tr>
			<tr>
				<td class="headVr p5px">Havelock</td>
				<td class="data p5px">Havelock Island Beach Resort/ Similar</td>
				<td class="data p5px">TSG Blue Resort/ NK Havelock Eco Resort / Similar</td>
				<td class="data p5px">Eldorado Beach Resort/ Gold India Beach Resort / Similar</td>
				<td class="data p5px">Gold Star Beach Resort/ Similar</td>
			</tr>
			<tr>
				<td class="headVr p5px">Neil Island</td>
				<td class="data p5px">Silver Sand Beach Resort/ Holiday Inn Beach Resort Similar</td>
				<td class="data p5px">Pearl Park Beach Resort / Similar</td>
				<td class="data p5px">Tango Beach Resort / Similar</td>
				<td class="data p5px">Neha Palace / Similar</td>
			</tr>
		</table></div><br>								</div>
																<div class="data mt20px p15px">            
								<div class="mb7px"> 
								<p class="b xlarge mb10px dib">Payments Terms</p>
								</div>
								
								<ul><li>•	Advance booking amount totally depends upon the type of package confirmed.</li><li>
•	 Booking amount is different for different destinations and it will be</li><li>
communicated to you by e mail.</li><li>
•	 Normal booking policy is as mentioned below:-</li><li>
1) 35 % of the total cost: - at the time of confirmation of package (non refundable).</li><li>
2) Remaining 25 % of the total cost: - 30 days before the departure.</li><li>
3) Remaining 40 % of the total cost: - 15 days before the departure.</li><li>
•	Please note that deadlines given to you for the payment are according to the cancellation policy. if you are failed to make the payments in time, your booking will be automatically released, and the cancellation amount will be as per the  payment deadlines.</li></ul>					
								</div>
														<div class="data mt20px p15px">            
						<div class="mb7px"> 
						<p class="b xlarge mb10px dib">Price &amp; Rates</p>
						</div>				
				        <table class="mb15px bdrall bdreee w100 p5px15px formTable">
			            	<tr class="headVr b">
			                	<td class="p5px10px">No of pax</td>
			                    <td class="p5px10px">Age Limit</td>
			                    <td class="p5px10px">Price per pax (Rs)</td>
			                </tr>

															<tr>
				            	<td class="p5px10px">Adult</td>
				                <td class="p5px10px">Above 12 years</td>
				                <td class="p5px10px">
			                				                		<b class="webrupee">INR</b>
			                					                	<b>10335</b> <small>/
			
			                		Adult			
			                				
			                		
			                	</small></td>
				            	</tr>
				            					         </table>
						</div>
					 								<div class="data mt20px p15px">            
							<div class="mb7px"> 
							<p class="b xlarge mb10px dib">TERMS & CONDITIONS: -</p>
							</div>
									
							<ul><li>The rooms & rates are subject to availability at the time of booking / confirmation.</li><li>
Hotel, sightseeing, meals, transfers and flight rate might change without any prior notice until & unless it been booked/ confirmed from your end.</li><li>
The change in dates will attract re-quote.</li><li>
Normal hotel check-in time is from 14.00 hrs. onwards. & check-out time is at 12.00 hrs.</li><li>
Additional bank charges will be applicable, if payment is made in foreign currency.</li><li>
The above cost does not include any kind of surcharge if applicable during the given travel period.</li><li>
There will be an additional cost for an entire transfer between 23:00 - 07:00 hrs.(if not stated inside the package).</li><li>
At check in all guests will be required to present a major credit card for incidentals. "No Show" is subject to full booking charges.</li><li>
Quotation might change due to currencies roe fluctuation during confirmation & booking process.</li><li>
All the vouchers, flight tickets will be sent 6 – 2 days before the departure.</li><li>
In case of group departures, if the minimum persons in a group is not complete in that case you will be adjusted in other group which may have different dates.</li><li>
Payment should be done according to the deadline given to you failed to do so will result in auto cancellation.</li><li>
In case of auto cancellation due to non-payment on or before the due date, cancellation charges will be there and sometimes whole of the payment done by you is non-refundable. in that SBSJ tours and travels will not be responsible and if you want to reconfirm your package you have to make the payment for that and whole of the booking will be processed again as a fresh booking.</li></ul>			
							</div>
														<div class="data mt20px p15px">            
							<div class="mb7px"> 
							<p class="b xlarge mb10px dib">Validity Period</p>
							</div>
									
							<ul><li>This package is valid till 31st march 2021.</li></ul>			
							</div>
													<div class="data mt20px p15px">            
						<div class="mb7px"> 
						<p class="b xlarge mb10px dib">Cancellation &amp; Refund Policy</p>
						</div>
								
						<ul><li>•	Cancellation / auto cancellation before 30 days of departure: - 50 % of the total cost.</li><li>
•	Cancellation / auto cancellation between 20 days to 16 days before the departure: - 60 % of the total cost.</li><li>
•	Cancellation / auto cancellation before 15 days of departure: - 100 % of the total cost.</li><li>
•	If you do not show up at the hotel or check-out early without advance notice you are not entitled to any refund. this term may be varied subject to the relevant hotel's private cancellation policy and is subject to change at any given time without prior notice.</li><li>
•	Cancellation policy is applicable per transaction and is based on individual component cancellation policy stated on the confirmation by mail, sent to you after confirmation of your booking with us on your e mail id.</li><li>
•	In case of cancellation due to non-payment according to booking policy given to you (auto cancellation),SBSJ tours and travels will not be responsible.</li><li>
•	You agree to pay any supplier required cancellation or change fees that you incur. in limited cases, some hotels do not permit changes to or cancellations of reservations after they are made. in that case you agree to abide by the terms and conditions imposed with respect to your prepaid hotel reservations.</li><li>
•	There may be full cancellation penalty on the products or services booked and purchased, which are non-utilized or cancelled after the payment deadline mentioned in the terms and conditions, while confirming your package.</li><li>
•	100 percent cancellation will be applicable, if you are cancelling the booking after the final instalment of the payment.</li><li>
Refund Policy: -</li><li>
•	When you cancel a booking and are entitled to a refund then we will instruct the refund as soon as practicable. The processing may take between 60 to 90 days until the whole amount is credited back and appears in your bank account given by you.</li><li>
•	Refunds will be transferred to your account only by neft/rtgs/cheque. no cash will be given for this</li><li>
Jurisdiction: -</li><li>
In the event of any dispute, the dispute shall be referred to the sole arbitrator to be appointed by SBSJ tours and travels in Ambala, Haryana and the matter shall be subjected to the jurisdiction of Ambala courts only.</li></ul>			
						</div>
												<div class="data mt20px p15px">            
						<div class="mb7px"> 
						<p class="b xlarge mb10px dib">Packages by Theme</p>
						</div>
													<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.sbsjonline.co.in/beach-islands-holidays-catid.htm" title="Beach and Islands Tour Packages">Beach and Islands Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.sbsjonline.co.in/surfing-holidays-catid.htm" title="Surfing Tour Packages">Surfing Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.sbsjonline.co.in/biking-holidays-catid.htm" title="Biking Tour Packages">Biking Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.sbsjonline.co.in/hill-station-holidays-catid.htm" title="Hill Station Tour Packages">Hill Station Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.sbsjonline.co.in/lakes-rivers-holidays-catid.htm" title="Lakes & Rivers Tour Packages">Lakes & Rivers Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.sbsjonline.co.in/sail-boats-holidays-catid.htm" title="Sail Boats Tour Packages">Sail Boats Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.sbsjonline.co.in/boat-safari-holidays-catid.htm" title="Boat Safari Tour Packages">Boat Safari Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.sbsjonline.co.in/snorkeling-holidays-catid.htm" title="Snorkeling Tour Packages">Snorkeling Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.sbsjonline.co.in/trekking-holidays-catid.htm" title="Trekking Tour Packages">Trekking Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.sbsjonline.co.in/valley-holidays-catid.htm" title="Valley Tour Packages">Valley Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/wildlife-nature-holidays-catid.htm" title="Wildlife and Nature Tour Packages">Wildlife and Nature Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/mountaineering-holidays-catid.htm" title="Mountaineering Tour Packages">Mountaineering Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/camping-holidays-catid.htm" title="Camping Tour Packages">Camping Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/jeep-safari-holidays-catid.htm" title="Jeep Safari Tour Packages">Jeep Safari Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/family-holidays-catid.htm" title="Family Tour Packages">Family Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/adventure-holidays-catid.htm" title="Adventure Tour Packages">Adventure Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/affordable-budget-holidays-catid.htm" title="Affordable & Budget Tour Packages">Affordable & Budget Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/heritage-holidays-catid.htm" title="Heritage Tour Packages">Heritage Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/religious-pilgrimage-holidays-catid.htm" title="Religious & Pilgrimage Tour Packages">Religious & Pilgrimage Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/safari-holidays-catid.htm" title="Safari Tour Packages">Safari Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/wildlife-safari-holidays-catid.htm" title="Wildlife Safari Tour Packages">Wildlife Safari Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/paragliding-holidays-catid.htm" title="Paragliding Tour Packages">Paragliding Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/motor-bike-holidays-catid.htm" title="Motor Bike Tour Packages">Motor Bike Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/skiing-holidays-catid.htm" title="Skiing Tour Packages">Skiing Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/heli-skiing-holidays-catid.htm" title="Heli Skiing Tour Packages">Heli Skiing Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/house-boat-holidays-catid.htm" title="House Boat Tour Packages">House Boat Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/food-drink-holidays-catid.htm" title="Food and Drink Tour Packages">Food and Drink Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/luxury-holidays-catid.htm" title="Luxury Tour Packages">Luxury Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/nightlife-holidays-catid.htm" title="Nightlife Tour Packages">Nightlife Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/adventure-sports-holidays-catid.htm" title="Adventure Sports Tour Packages">Adventure Sports Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/water-sports-activity-holidays-catid.htm" title="Water Sports and Activity Tour Packages">Water Sports and Activity Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/jet-ski-ride-holidays-catid.htm" title="Jet Ski Ride Tour Packages">Jet Ski Ride Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/forts-palaces-holidays-catid.htm" title="Forts and Palaces Tour Packages">Forts and Palaces Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/camel-safari-holidays-catid.htm" title="Camel Safari Tour Packages">Camel Safari Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/hiking-holidays-catid.htm" title="Hiking Tour Packages">Hiking Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/national-parks-holidays-catid.htm" title="National Parks Tour Packages">National Parks Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.sbsjonline.co.in/honeymoon-holidays-catid.htm" title="Honeymoon Tour Packages">Honeymoon Tours</a></span>
														<span class="uu db ar"><a class="showallspan" data-target="show" href="javascript:void(0)" >View More</a></span>
													</div>
												
						<div class="ac mb10px">
						<form class="inquiry-form" name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.sbsjonline.co.in/enquiry-form-10028.htm">
						<input type="hidden" name="subject" value="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n) - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>							
						<input type="hidden" name="pkg_slno" value="198084"/>
						</form>
						<a href="javascript:void(0);" class="submit-inquiry button p7px pl12px pr12px c5px b large dib mt10px">Book Your Tour</a>
						</div>
											<div id="myModal" class="modal fade dn pf" role="dialog" style="z-index:9999;left:0;top:0%;width:100%;height:100%;background-color:rgba(0,0,0,0.6);overflow-x: hidden; overflow-y: auto;">
					    <!-- Modal content-->
					    <div style="max-width:380px;margin-top: 50px;min-height:400px;" class="modal-content data m0a p10px pr">
					      <div class="modal-header">
					        <a style="right:25px;top:25px;" class="pa b xxxlarge" data-dismiss="modal"><span class="xlarge">&times;</span></a>	        
					      </div>
					      <div class="modal-body">
					        <p>Loading...</p>
					      </div>
					      <div class="modal-footer">
					        
					      </div>
					    </div>
					</div>
					<script type="text/javascript">
						jQuery(document).ready(function(){
							jQuery(document).on("click", ".submit-inquiry" , function(e){e.stopPropagation()
								var form = jQuery(this).parent().find(".inquiry-form");
								if(form.length){
									jQuery.ajax({
										url: form.attr("action"),
										type: form.attr("method"),
										data:form.serialize(),
										crossDomain:true,
										success:function(res){
											jQuery("#myModal .modal-body").html(res);
										}
									});
								}
							});
							jQuery(document).on("click", "[data-dismiss=modal]", function(){
								jQuery("#myModal .modal-body").html("<p>Loading...</p>");
								jQuery("#myModal").hide();
							});
							jQuery(document).on("submit", "form[name=static_form]", function(e){				
								e.preventDefault();
								var isValidForm =static_inq_form_validate(jQuery(this).attr("form-id"));
								if(isValidForm == undefined){
									var form = jQuery(this);
									if(form.length){
										jQuery.ajax({
											url: form.attr("action"),
											type: form.attr("method"),
											data:form.serialize(),
											crossDomain:true,
											beforeSend:function(){
												jQuery("#myModal .modal-footer").html("");
											},
											success:function(res){
												jQuery("#myModal .modal-body").html(res);
												setTimeout(function(){
													jQuery("#myModal", document).hide();
													jQuery("#myModal .modal-body").html("<p>Loading...</p>");
													},2000)
											}
										});
									}
								}
							});
							var modal = jQuery("#myModal", document);
				
							jQuery(document).on("click", ".submit-inquiry" , function(){
							    modal.show();
							});
				
							window.onclick = function(event) {
							    if (jQuery(event.target) == modal) {
							        modal.css("display","none");
							    }
							}
						});
					</script>
									</div>
									<div class="col-2 rightPropEnq"><!--MIDDLE ROW1 COL-1 STARTS-->
					<div class="column_Box mc rghtFix">
					<div class="tcl bullet data divider p10px pt20px enqForm stickyForm">
					<div class="h h2 ac fw6 xxxlarge"><b class="plusMinus"></b>
					Fill Enquiry Form Below
					</div>
					<div class="showHide_rp mt7px">
					<form name="package_form" method="post" action="//catalog.tourtravelworld.com/catalog-enquiry.php" onsubmit="return static_inq_form_validate(10029);">
					<div class="fo mt25px">
					<div class="mb15px">
					<input type="text" name="dynFrm_contact_person" id="dynFrm_contact_person_10029" placeholder="Your Full Name" />
					<span class="red small"></span>
					</div>
					<div class="fl w100 mb15px">
					<textarea name="dynFrm_details_2" id="dynFrm_details_2_10029">I am interested in Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n). Please get in contact with me.</textarea>
					<span class="fl red small"></span>
					</div>
					<div class="fl w100 mb15px df-dt">
					<div class="df-dtc w50 pr5px dateOpt pr"><input type="text" name="dynFrm_arrival_date" id="dynFrm_arrival_date_10029" class="dynFrm_arrival_date" style="padding-left:30px;" placeholder=" Departure Date" /><span class="fl red small"></span></div>
					<div class="df-dtc pl5px"><input type="text" name="dynFrm_duration" id="dynFrm_duration_10029" placeholder="Number of Days" /><span class="fl red small"></span></div>
					</div>  
					<div class="mb15px">
					<input type="text" name="dynFrm_email_id" id="dynFrm_email_id_10029" placeholder="Email" />
					<span class="red small"></span>
					</div> 
					<div class="mb20px fl w100">
					<div class="w60px pr fl ofh">
					<div id="isdpackCode" class="isdCode pr0px">+91</div>
					<select class="contSelect" name="dynFrm_country" id="dynFrm_country" onChange="document.getElementById('phone_package_isd').value=this.value.substr(3, 4); document.getElementById('isdpackCode').innerHTML=this.value.substr(3, 4);">
					
											
						<option value="AF^+93" >Afghanistan +93</option>
					
												
						<option value="CF^+236" >African Republic +236</option>
					
												
						<option value="AL^+355" >Albania +355</option>
					
												
						<option value="DZ^+213" >Algeria +213</option>
					
												
						<option value="AS^+0" >American Samoa +0</option>
					
												
						<option value="AD^+376" >Andorra +376</option>
					
												
						<option value="AO^+244" >Angola +244</option>
					
												
						<option value="AI^+264" >Anguilla +264</option>
					
												
						<option value="AG^+268" >Antigua and Barbuda +268</option>
					
												
						<option value="AR^+54" >Argentina +54</option>
					
												
						<option value="AM^+374" >Armenia +374</option>
					
												
						<option value="AW^+297" >Aruba +297</option>
					
												
						<option value="AU^+61" >Australia +61</option>
					
												
						<option value="AT^+43" >Austria +43</option>
					
												
						<option value="AZ^+994" >Azerbaijan +994</option>
					
												
						<option value="BS^+242" >Bahamas +242</option>
					
												
						<option value="BH^+973" >Bahrain +973</option>
					
												
						<option value="BD^+880" >Bangladesh +880</option>
					
												
						<option value="BB^+246" >Barbados +246</option>
					
												
						<option value="BY^+375" >Belarus +375</option>
					
												
						<option value="BE^+32" >Belgium +32</option>
					
												
						<option value="BZ^+501" >Belize +501</option>
					
												
						<option value="BJ^+229" >Benin +229</option>
					
												
						<option value="BM^+441" >Bermuda +441</option>
					
												
						<option value="BT^+975" >Bhutan +975</option>
					
												
						<option value="BO^+591" >Bolivia +591</option>
					
												
						<option value="BA^+387" >Bosnia and Herzegovina +387</option>
					
												
						<option value="BW^+267" >Botswana +267</option>
					
												
						<option value="BV^+47" >Bouvet +47</option>
					
												
						<option value="BR^+55" >Brazil +55</option>
					
												
						<option value="BN^+673" >Brunei +673</option>
					
												
						<option value="BG^+359" >Bulgaria +359</option>
					
												
						<option value="BF^+226" >Burkina +226</option>
					
												
						<option value="BF^+0" >Burkina Faso +0</option>
					
												
						<option value="BI^+257" >Burundi +257</option>
					
												
						<option value="KH^+855" >Cambodia +855</option>
					
												
						<option value="CM^+237" >Cameroon +237</option>
					
												
						<option value="CA^+1" >Canada +1</option>
					
												
						<option value="CV^+238" >Cape Verde +238</option>
					
												
						<option value="KY^+345" >Cayman Islands +345</option>
					
												
						<option value="236^+236" >Central African Republic +236</option>
					
												
						<option value="TD^+235" >Chad +235</option>
					
												
						<option value="IO^+246" >Chagos +246</option>
					
												
						<option value="CL^+56" >Chile +56</option>
					
												
						<option value="CN^+86" >China +86</option>
					
												
						<option value="CX^+61" >Christmas Island +61</option>
					
												
						<option value="CC^+61" >Cocos +61</option>
					
												
						<option value="CO^+57" >Colombia +57</option>
					
												
						<option value="KM^+269" >Comoros +269</option>
					
												
						<option value="CG^+242" >Congo +242</option>
					
												
						<option value="CK^+682" >Cook Islands +682</option>
					
												
						<option value="RCI^+506" >Costa Rica +506</option>
					
												
						<option value="HR^+385" >Croatia +385</option>
					
												
						<option value="CY^+357" >Cyprus +357</option>
					
												
						<option value="CZ^+420" >Czech Republic +420</option>
					
												
						<option value="DK^+45" >Denmark +45</option>
					
												
						<option value="DJ^+253" >Djibouti +253</option>
					
												
						<option value="DM^+767" >Dominica +767</option>
					
												
						<option value="DO^+809" >Dominican Republic +809</option>
					
												
						<option value="TP^+670" >East Timor +670</option>
					
												
						<option value="EC^+593" >Ecuador +593</option>
					
												
						<option value="EG^+20" >Egypt +20</option>
					
												
						<option value="SV^+503" >El Salvador +503</option>
					
												
						<option value="GQ^+0" >Equatorial Guinea +0</option>
					
												
						<option value="ER^+291" >Eritrea +291</option>
					
												
						<option value="EE^+372" >Estonia +372</option>
					
												
						<option value="ET^+251" >Ethiopia +251</option>
					
												
						<option value="FO^+298" >Faroe +298</option>
					
												
						<option value="FM^+691" >Federated States of Micronesia +691</option>
					
												
						<option value="FJ^+679" >Fiji +679</option>
					
												
						<option value="FI^+358" >Finland +358</option>
					
												
						<option value="FR^+33" >France +33</option>
					
												
						<option value="FX^+590" >France, Metropolitan +590</option>
					
												
						<option value="GF^+594" >French Guiana +594</option>
					
												
						<option value="FP^+689" >French Polynesia +689</option>
					
												
						<option value="TF^+590" >French Southern Territories +590</option>
					
												
						<option value="GA^+241" >Gabon +241</option>
					
												
						<option value="GM^+220" >Gambia +220</option>
					
												
						<option value="GE^+995" >Georgia +995</option>
					
												
						<option value="DE^+49" >Germany +49</option>
					
												
						<option value="GH^+233" >Ghana +233</option>
					
												
						<option value="GI^+350" >Gibraltar +350</option>
					
												
						<option value="GR^+30" >Greece +30</option>
					
												
						<option value="GL^+299" >Greenland +299</option>
					
												
						<option value="GD^+809" >Grenada +809</option>
					
												
						<option value="Gre^+473" >Grenada +473</option>
					
												
						<option value="GP^+590" >Guadeloupe +590</option>
					
												
						<option value="GU^+1" >Guam +1</option>
					
												
						<option value="GT^+502" >Guatemala +502</option>
					
												
						<option value="GN^+224" >Guinea +224</option>
					
												
						<option value="GW^+245" >Guinea-bissau +245</option>
					
												
						<option value="GY^+592" >Guyana +592</option>
					
												
						<option value="HT^+509" >Haiti +509</option>
					
												
						<option value="HM^+61" >Heard and Mc Donald Islands +61</option>
					
												
						<option value="HN^+504" >Honduras +504</option>
					
												
						<option value="HU^+36" >Hungary +36</option>
					
												
						<option value="IS^+354" >Iceland +354</option>
					
												
						<option value="IN^+91"  selected="selected" >India +91</option>
					
												
						<option value="ID^+62" >Indonesia +62</option>
					
												
						<option value="IQ^+964" >Iraq +964</option>
					
												
						<option value="IE^+353" >Ireland +353</option>
					
												
						<option value="IL^+972" >Israel +972</option>
					
												
						<option value="IT^+39" >Italy +39</option>
					
												
						<option value="CI^+225" >Ivory Coast +225</option>
					
												
						<option value="JM^+876" >Jamaica +876</option>
					
												
						<option value="JP^+81" >Japan +81</option>
					
												
						<option value="JO^+962" >Jordan +962</option>
					
												
						<option value="KZ^+7" >Kazakhstan +7</option>
					
												
						<option value="KE^+254" >Kenya +254</option>
					
												
						<option value="KI^+686" >Kiribati +686</option>
					
												
						<option value="KW^+965" >Kuwait +965</option>
					
												
						<option value="KG^+996" >Kyrgyzstan +996</option>
					
												
						<option value="LA^+856" >Lao People's Democratic Republic +856</option>
					
												
						<option value="LA^+856" >Laos +856</option>
					
												
						<option value="LV^+371" >Latvia +371</option>
					
												
						<option value="LB^+961" >Lebanon +961</option>
					
												
						<option value="LS^+266" >Lesotho +266</option>
					
												
						<option value="LR^+231" >Liberia +231</option>
					
												
						<option value="LY^+218" >Libya +218</option>
					
												
						<option value="LI^+423" >Liechtenstein +423</option>
					
												
						<option value="LT^+370" >Lithuania +370</option>
					
												
						<option value="LU^+352" >Luxembourg +352</option>
					
												
						<option value="MO^+853" >Macau +853</option>
					
												
						<option value="MK^+389" >Macedonia +389</option>
					
												
						<option value="MG^+261" >Madagascar +261</option>
					
												
						<option value="MW^+265" >Malawi +265</option>
					
												
						<option value="MY^+60" >Malaysia +60</option>
					
												
						<option value="MV^+960" >Maldives +960</option>
					
												
						<option value="ML^+223" >Mali +223</option>
					
												
						<option value="MT^+356" >Malta +356</option>
					
												
						<option value="FK^+500" >Malvinas +500</option>
					
												
						<option value="MH^+692" >Marshall Islands +692</option>
					
												
						<option value="MQ^+596" >Martinique +596</option>
					
												
						<option value="MR^+222" >Mauritania +222</option>
					
												
						<option value="MU^+230" >Mauritius +230</option>
					
												
						<option value="YT^+269" >Mayotte +269</option>
					
												
						<option value="MX^+52" >Mexico +52</option>
					
												
						<option value="MD^+0" >Moldova +0</option>
					
												
						<option value="MD^+373" >Moldova (Republic of Moldova) +373</option>
					
												
						<option value="MC^+377" >Monaco +377</option>
					
												
						<option value="MN^+976" >Mongolia +976</option>
					
												
						<option value="ME^+381" >Montenegro +381</option>
					
												
						<option value="MS^+664" >Montserrat +664</option>
					
												
						<option value="MA^+212" >Morocco +212</option>
					
												
						<option value="MZ^+258" >Mozambique +258</option>
					
												
						<option value="MM^+95" >Myanmar +95</option>
					
												
						<option value="NA^+264" >Namibia +264</option>
					
												
						<option value="NR^+674" >Nauru +674</option>
					
												
						<option value="NP^+977" >Nepal +977</option>
					
												
						<option value="NL^+31" >Netherlands +31</option>
					
												
						<option value="AN^+599" >Netherlands Antilles +599</option>
					
												
						<option value="NC^+687" >New Caledonia +687</option>
					
												
						<option value="PG^+675" >New Guinea +675</option>
					
												
						<option value="NZ^+64" >New Zealand +64</option>
					
												
						<option value="NI^+505" >Nicaragua +505</option>
					
												
						<option value="NE^+227" >Niger +227</option>
					
												
						<option value="NG^+234" >Nigeria +234</option>
					
												
						<option value="NU^+683" >Niue +683</option>
					
												
						<option value="NF^+672" >Norfolk Island +672</option>
					
												
						<option value="MP^+670" >Northern Mariana Islands +670</option>
					
												
						<option value="NO^+47" >Norway +47</option>
					
												
						<option value="OM^+968" >Oman +968</option>
					
												
						<option value="PK^+92" >Pakistan +92</option>
					
												
						<option value="PW^+680" >Palau +680</option>
					
												
						<option value="PA^+507" >Panama +507</option>
					
												
						<option value="PG^+0" >Papua New Guinea +0</option>
					
												
						<option value="PY^+595" >Paraguay +595</option>
					
												
						<option value="PE^+51" >Peru +51</option>
					
												
						<option value="PH^+63" >Philippines +63</option>
					
												
						<option value="PN^+872" >Pitcairn +872</option>
					
												
						<option value="PL^+48" >Poland +48</option>
					
												
						<option value="PF^+689" >Polynesia +689</option>
					
												
						<option value="PT^+351" >Portugal +351</option>
					
												
						<option value="PR^+1-787" >Puerto Rico +1-787</option>
					
												
						<option value="QA^+974" >Qatar +974</option>
					
												
						<option value="RE^+262" >Reunion +262</option>
					
												
						<option value="RO^+40" >Romania +40</option>
					
												
						<option value="RU^+7" >Russia +7</option>
					
												
						<option value="RW^+250" >Rwanda +250</option>
					
												
						<option value="KN^+869" >Saint Kitts and Nevis +869</option>
					
												
						<option value="LC^+758" >Saint Lucia +758</option>
					
												
						<option value="VC^+784" >Saint Vincent and the Grenadines +784</option>
					
												
						<option value="WS^+685" >Samoa +685</option>
					
												
						<option value="SM^+378" >San Marino +378</option>
					
												
						<option value="ST^+239" >Sao Tome And Principe +239</option>
					
												
						<option value="SA^+966" >Saudi Arabia +966</option>
					
												
						<option value="SN^+221" >Senegal +221</option>
					
												
						<option value="RS^+381" >Serbia +381</option>
					
												
						<option value="SC^+248" >Seychelles +248</option>
					
												
						<option value="SL^+232" >Sierra Leone +232</option>
					
												
						<option value="SG^+65" >Singapore +65</option>
					
												
						<option value="SK^+421" >Slovakia +421</option>
					
												
						<option value="SI^+386" >Slovenia +386</option>
					
												
						<option value="SB^+677" >Solomon Islands +677</option>
					
												
						<option value="SO^+252" >Somalia +252</option>
					
												
						<option value="ZA^+27" >South Africa +27</option>
					
												
						<option value="GS^+44" >South Georgia and the South Sandwich Islands +44</option>
					
												
						<option value="KR^+82" >South Korea +82</option>
					
												
						<option value="ES^+34" >Spain +34</option>
					
												
						<option value="LK^+94" >Sri Lanka +94</option>
					
												
						<option value="SH^+290" >St. Helena +290</option>
					
												
						<option value="PM^+508" >St. Pierre and Miquelon +508</option>
					
												
						<option value="SD^+249" >Sudan +249</option>
					
												
						<option value="SR^+597" >Suriname +597</option>
					
												
						<option value="SJ^+47" >Svalbard and Jan Mayen Islands +47</option>
					
												
						<option value="SZ^+268" >Swaziland +268</option>
					
												
						<option value="SE^+46" >Sweden +46</option>
					
												
						<option value="CH^+41" >Switzerland +41</option>
					
												
						<option value="TW^+886" >Taiwan +886</option>
					
												
						<option value="TJ^+7" >Tajikistan +7</option>
					
												
						<option value="TZ^+255" >Tanzania +255</option>
					
												
						<option value="TH^+66" >Thailand +66</option>
					
												
						<option value="TG^+228" >Togo +228</option>
					
												
						<option value="TK^+64" >Tokelau +64</option>
					
												
						<option value="TO^+676" >Tonga +676</option>
					
												
						<option value="TT^+868" >Trinidad and Tobago +868</option>
					
												
						<option value="TN^+216" >Tunisia +216</option>
					
												
						<option value="TR^+90" >Turkey +90</option>
					
												
						<option value="TM^+993" >Turkmenistan +993</option>
					
												
						<option value="TC^+649" >Turks and Caicos Islands +649</option>
					
												
						<option value="TV^+688" >Tuvalu +688</option>
					
												
						<option value="AE^+971" >UAE +971</option>
					
												
						<option value="UG^+256" >Uganda +256</option>
					
												
						<option value="UA^+380" >Ukraine +380</option>
					
												
						<option value="UK^+44" >United Kingdom +44</option>
					
												
						<option value="UM^+1" >United States Minor Outlying Islands +1</option>
					
												
						<option value="UY^+598" >Uruguay +598</option>
					
												
						<option value="US^+1" >USA +1</option>
					
												
						<option value="UZ^+998" >Uzbekistan +998</option>
					
												
						<option value="VU^+678" >Vanuatu +678</option>
					
												
						<option value="VA^+0" >Vatican City +0</option>
					
												
						<option value="VA^+39" >Vatican City State (Holy See) +39</option>
					
												
						<option value="VE^+58" >Venezuela +58</option>
					
												
						<option value="VN^+84" >Vietnam +84</option>
					
												
						<option value="VG^+1" >Virgin Islands (British) +1</option>
					
												
						<option value="VI^+1" >Virgin Islands (U.S.) +1</option>
					
												
						<option value="WF^+681" >Wallis and Futuna Islands +681</option>
					
												
						<option value="EH^+212" >Western Sahara +212</option>
					
												
						<option value="YE^+967" >Yemen +967</option>
					
												
						<option value="YU^+381" >Yugoslavia +381</option>
					
												
						<option value="ZR^+243" >Zaire +243</option>
					
												
						<option value="ZM^+260" >Zambia +260</option>
					
												
						<option value="ZW^+263" >Zimbabwe +263</option>
					
											</select>
					</div>									
					<input type="text" name="dynFrm_phone" id="dynFrm_phone_10029" class="fl" style="width:calc(100% - 62px);" placeholder="Mobile No" />
					<span class="fl red small"></span>
					</div>
					
					<div class="mt25px mb15px">
					<input type="submit" name="submit" value="Send Enquiry" class="db theme2 xlarge fw6 p12px bdr ttu">
					<input type="hidden" name="phone_isd" id="phone_package_isd" value="+91">
					<input type="hidden" name="subject" value="Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n) - Tour Package"/>
					<input type="hidden" name="allocate_type" value="tour"/>
					<input type="hidden" name="pkg_slno" value="198084"/>
					<input type="hidden" name="current_url" value="https://www.sbsjonline.co.in/tour-packages/paradiseon-earth-port-blair3n-havelock1n-neil-island1n.htm">
				  	<input type="hidden" name="web_address" value="https://www.sbsjonline.co.in">
				  	<input type="hidden" name="inq_thanks_msg" value="Thank you for inquiry.<br /><br />We have received your request. Our Sales Team will soon get in touch with you.<br /><br /><br />">
					<input type="hidden" name="inq_thanks_title" value="Enquiry">
				  	<input type="hidden" name="redirected_url" value="https://www.sbsjonline.co.in/thanks.htm">
					<input type="hidden" name="catalog_mi" value="434226">
				  	<input type="hidden" name="id" value="static_form">
				  	<input type="hidden" name="form_id" value="10029">
					</form>
					</div>
					</div>					
					</div>
					</div>
					<style>
					.ui-datepicker-trigger {
						vertical-align : middle;
					}
					</style>
					<script>
					jQuery('.dynFrm_arrival_date').datepicker({minDate: 0,
					buttonImage: '//catalog.wlimg.com/jquery-date-picker/calbtn.gif',
					buttonText: 'Click to view calendar',
				    buttonImageOnly: true,
				    showOn: 'button',
				    changeMonth: true,
				    changeYear: true,
				    onClose: function(dateText, inst) {
				        var endDateTextBox = jQuery('.dynFrm_departure_date');
				        if (endDateTextBox.val() != '') {
				            var testStartDate = new Date(dateText);
				            var testEndDate = new Date(endDateTextBox.val());
				            if (testStartDate > testEndDate)
				                endDateTextBox.val(dateText);
				        }
				    }, 
					    onSelect: function (selectedDateTime){
					        var start = jQuery(this).datepicker('getDate');
					        jQuery('.dynFrm_departure_date').datepicker('option', 'minDate', new Date(start.getTime()));
					        jQuery('#dynFrm_departure_date').datepicker('option', 'minDate', new Date(start.getTime()));
					    }    
					});
					jQuery('.dynFrm_departure_date').datepicker({
					minDate: 0,
					buttonImage: '//catalog.wlimg.com/jquery-date-picker/calbtn.gif',
					buttonText: 'Click to view calendar',
				    buttonImageOnly: true,
				    showOn: 'button',
				    changeMonth: true,
				    changeYear: true,
				    onClose: function(dateText, inst) {
				        var startDateTextBox = jQuery('.dynFrm_arrival_date');
				        if (startDateTextBox.val() != '') {
				            var testStartDate = new Date(startDateTextBox.val());
				            var testEndDate = new Date(dateText);
				            if (testStartDate > testEndDate)
				                startDateTextBox.val(dateText);
				        }
				    },
				    onSelect: function (selectedDateTime){
				        var end = jQuery(this).datepicker('getDate');
				        jQuery('.dynFrm_arrival_date').datepicker('option', 'maxDate', new Date(end.getTime()) );
				        jQuery('#dynFrm_arrival_date').datepicker('option', 'maxDate', new Date(end.getTime()) );
				    }
					});
					</script>
					<script>
					jQuery(document).ready(function(){
					var sticky = jQuery('.stickyForm').offset().top;
					jQuery(window).scroll(function(){      
					 if(jQuery(window).scrollTop() > sticky){
					  jQuery('.stickyForm').css('position','fixed');
					  jQuery('.stickyForm').css('top','50px'); 
					 }
					 else if (jQuery(window).scrollTop() <= sticky) {
					  jQuery('.stickyForm').css('position','');
					  jQuery('.stickyForm').css('top','');
					 }  
					if (jQuery('.stickyForm').offset().top + jQuery(".stickyForm").height() > jQuery(".rel-prop").offset().top) {
					  jQuery('.stickyForm').css('top',-(jQuery(".stickyForm").offset().top + jQuery(".stickyForm").height() - jQuery(".rel-prop").offset().top));
					}
					});
					});
					</script>
					
					</div>
					</div>
									
				
				</div>
				
										<br />
						<section class="pt20px pb20px relTour-pkg rel-prop"><br>
						<div class="wrap">      	
						<div class="myTabs mc bdr0 horizontal987 hot bdr0"><div class=""><ul class="fo lsn m0px p0px"><li class="h hd_h2"><div class="ac"><h2 class="hd_NT">Similar Tour Packages for Port Blair, Havelock, Genting, Moga</h2></div></li></ul></div><p class="cb"></p>
						<div class="ic" id="1102_3-1">
						<div class="slider">
						<ul class="bxslider987">
											
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.sbsjonline.co.in/tour-packages/incredible-andaman-port-blair4n-havelock1n-neil-island1n.htm'">
															<div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317325.jpg"  height=""  width=""    alt="Incredible Andaman (Port Blair 4N + Havelock 1N + Neil Island 1N)" title="Incredible Andaman (Port Blair 4N + Havelock 1N + Neil Island 1N)"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="https://www.sbsjonline.co.in/tour-packages/incredible-andaman-port-blair4n-havelock1n-neil-island1n.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								6 Nights / 7 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.sbsjonline.co.in/tour-packages/incredible-andaman-port-blair4n-havelock1n-neil-island1n.htm" title="Incredible Andaman (Port Blair 4N + Havelock 1N + Neil Island 1N)"><h3>Incredible Andaman (port Blair 4n + Havelock 1n + Neil Island 1n)</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.sbsjonline.co.in/tour-packages/wandoor-beach-tour-port-blair4n-havelock2n-neil-island1n.htm'">
															<div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317336.jpg"  height=""  width=""    alt="Wandoor Beach Tour (Port Blair 4N + Havelock 2N + Neil Island 1N)" title="Wandoor Beach Tour (Port Blair 4N + Havelock 2N + Neil Island 1N)"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="https://www.sbsjonline.co.in/tour-packages/wandoor-beach-tour-port-blair4n-havelock2n-neil-island1n.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								7 Nights / 8 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.sbsjonline.co.in/tour-packages/wandoor-beach-tour-port-blair4n-havelock2n-neil-island1n.htm" title="Wandoor Beach Tour (Port Blair 4N + Havelock 2N + Neil Island 1N)"><h3>Wandoor Beach Tour (port Blair 4n + Havelock 2n + Neil Island 1n)</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.sbsjonline.co.in/tour-packages/exotic-andaman-port-blair3n-havelock2n-neil-island1n.htm'">
															<div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317315.jpg"  height=""  width=""    alt="Exotic Andaman (Port Blair 3N + Havelock 2N + Neil Island 1N)" title="Exotic Andaman (Port Blair 3N + Havelock 2N + Neil Island 1N)"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="https://www.sbsjonline.co.in/tour-packages/exotic-andaman-port-blair3n-havelock2n-neil-island1n.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								6 Nights / 7 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.sbsjonline.co.in/tour-packages/exotic-andaman-port-blair3n-havelock2n-neil-island1n.htm" title="Exotic Andaman (Port Blair 3N + Havelock 2N + Neil Island 1N)"><h3>Exotic Andaman (port Blair 3n + Havelock 2n + Neil Island 1n)</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.sbsjonline.co.in/tour-packages/splendid-andaman-port-blair3n-havelock1n1.htm'">
															<div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317363.jpg"  height=""  width=""    alt="Splendid Andaman (Port Blair 3N + Havelock 1N)" title="Splendid Andaman (Port Blair 3N + Havelock 1N)"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="https://www.sbsjonline.co.in/tour-packages/splendid-andaman-port-blair3n-havelock1n1.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								4 Nights / 5 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.sbsjonline.co.in/tour-packages/splendid-andaman-port-blair3n-havelock1n1.htm" title="Splendid Andaman (Port Blair 3N + Havelock 1N)"><h3>Splendid Andaman (port Blair 3n + Havelock 1n)</h3></a></div>
							</div>
							</div>						
							</li>
															
						</ul>
						</div>
						</div> 
													<style>
							.relTour-pkg .slider ul li{max-width:214px;margin-bottom:20px;padding-left:5px;padding-right:6px;box-sizing:border-box;margin-right:12px;}
							</style>	
														  
						 </div>
					     </div>
					    </section>
										<section class="pt20px pb20px absTour-Title rel-prop"><br>
				<div class="wrap">      	
				<div class="myTabs mc bdr0 horizontal987 hot bdr0"><div class=""><ul class="fo lsn m0px p0px"><li class="h hd_h2"><div class="ac"><h2 class="hd_NT">Explore Tour Packages by Destination</h2></div></li></ul></div><p class="cb"></p>
				<div class="ic" id="1102_3-1">
				<div class="slider">
				<ul class="bxslider988">								
				
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="https://www.sbsjonline.co.in/packages-in-leh-ladakh.htm" title="Packages in Leh Ladakh" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317587.jpg"  height=""  width=""    alt="Packages in Leh Ladakh" title="Packages in Leh Ladakh"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.sbsjonline.co.in/packages-in-leh-ladakh.htm" title="Packages in Leh Ladakh">Leh Ladakh Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="https://www.sbsjonline.co.in/packages-in-gangtok.htm" title="Packages in Gangtok" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317425.jpg"  height=""  width=""    alt="Packages in Gangtok" title="Packages in Gangtok"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.sbsjonline.co.in/packages-in-gangtok.htm" title="Packages in Gangtok">Gangtok Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="https://www.sbsjonline.co.in/packages-in-port-blair.htm" title="Packages in Port Blair" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317327.jpg"  height=""  width=""    alt="Packages in Port Blair" title="Packages in Port Blair"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.sbsjonline.co.in/packages-in-port-blair.htm" title="Packages in Port Blair">Port Blair Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="https://www.sbsjonline.co.in/packages-in-manali.htm" title="Packages in Manali" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/318304.jpg"  height=""  width=""    alt="Packages in Manali" title="Packages in Manali"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.sbsjonline.co.in/packages-in-manali.htm" title="Packages in Manali">Manali Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="https://www.sbsjonline.co.in/packages-in-havelock.htm" title="Packages in Havelock" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317362.jpg"  height=""  width=""    alt="Packages in Havelock" title="Packages in Havelock"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.sbsjonline.co.in/packages-in-havelock.htm" title="Packages in Havelock">Havelock Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="https://www.sbsjonline.co.in/packages-in-pelling.htm" title="Packages in Pelling" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317560.jpg"  height=""  width=""    alt="Packages in Pelling" title="Packages in Pelling"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.sbsjonline.co.in/packages-in-pelling.htm" title="Packages in Pelling">Pelling Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="https://www.sbsjonline.co.in/packages-in-kargil.htm" title="Packages in Kargil" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317482.jpg"  height=""  width=""    alt="Packages in Kargil" title="Packages in Kargil"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.sbsjonline.co.in/packages-in-kargil.htm" title="Packages in Kargil">Kargil Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="https://www.sbsjonline.co.in/packages-in-lachung.htm" title="Packages in Lachung" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317423.jpg"  height=""  width=""    alt="Packages in Lachung" title="Packages in Lachung"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.sbsjonline.co.in/packages-in-lachung.htm" title="Packages in Lachung">Lachung Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="https://www.sbsjonline.co.in/packages-in-darjeeling.htm" title="Packages in Darjeeling" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317393.jpeg"  height=""  width=""    alt="Packages in Darjeeling" title="Packages in Darjeeling"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.sbsjonline.co.in/packages-in-darjeeling.htm" title="Packages in Darjeeling">Darjeeling Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="https://www.sbsjonline.co.in/packages-in-moga.htm" title="Packages in Moga" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/317308.jpg"  height=""  width=""    alt="Packages in Moga" title="Packages in Moga"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.sbsjonline.co.in/packages-in-moga.htm" title="Packages in Moga">Moga Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="https://www.sbsjonline.co.in/packages-in-shimla.htm" title="Packages in Shimla" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/318301.jpg"  height=""  width=""    alt="Packages in Shimla" title="Packages in Shimla"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.sbsjonline.co.in/packages-in-shimla.htm" title="Packages in Shimla">Shimla Tours</a></div>
					</div> 
					</li>
					
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="https://www.sbsjonline.co.in/packages-in-munnar.htm" title="Packages in Munnar" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/434226/318531.jpg"  height=""  width=""    alt="Packages in Munnar" title="Packages in Munnar"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.sbsjonline.co.in/packages-in-munnar.htm" title="Packages in Munnar">Munnar Tours</a></div>
					</div> 
					</li>
									</ul>
				</div>
				</div>
				 
					<script>
					$(document).ready(function(){			
					$('.bxslider988').bxSlider({
					mode:'horizontal',				
					slideWidth: 214,maxSlides: 10,slideMargin:12,auto: true, 
					autoDirection:'next',
					moveSlides: 1,
					pause:2000,
					pager:false,
					pagerType:'full',
					autoControls: false, 
					controls:true, 
					autoHover:true,				
					speed:1000
					});
					});
					</script>
									
				</div>
				</div><br><br>
				</section>
				
				</div>
				</section>
				
				<script>
					window.addEventListener("DOMContentLoaded", function(){
						jQuery(document).on("click", ".showallspan", function(){
							if(jQuery(this).attr("data-target") === 'show'){
								jQuery(this).text("View Less");
								jQuery(this).attr("data-target", "hide");
								jQuery(this).closest("div").find(".spanlist").removeClass("dn");
							}else{
								jQuery(this).text("View More");
								jQuery(this).attr("data-target", "show");
								jQuery(this).closest("div").find(".spanlist").addClass("dn");
							}
						});
					});
				</script>
				";i:1;s:103:"Book Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n) - 5 Nights / 6 Days Tour Packages";i:2;s:187:"book paradise on earth (port blair 3n + havelock 1n + neil island 1n) - 5 nights / 6 days tour packages, beach and islands tour packages, port blair, havelock, genting, moga tour packages";i:3;s:226:"Sbsj Tours and Travels offers Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n) - 5 Nights / 6 Days tour package, budget Beach and Islands tour packages for Port Blair, Havelock, Genting, Moga at exciting price.";i:4;s:784:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Port Blair, Havelock, Genting, Moga"        
		                 },
		      "description": "*03 Nights accommodation in Port Blair.
*01 Nights accommodation in Havelock.
*01 Nights accommodation in Neil Island.
*Daily breakfast at the hotel.
*A/C Car for All Package for Sightseeing and excursions as per our brochure itinerary.
*Meal plan as per you choose.
*5.00 % Government service tax ( extra).",
		      "name": "Paradise On Earth (port Blair 3n + Havelock 1n + Neil Island 1n)",
		      "telephone": "+91-9896556490"
		    }
		    </script>
			";i:5;N;}