a:6:{i:0;s:11130:"				<div class="h1"><h1>Hotel Le Seasons:  3N/4D Package</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.saisaharatravels.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.saisaharatravels.com/packages.htm" title="Packages">Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Hotel Le Seasons:  3N/4D Package</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">Duration </td>
						<td class="p5px pl0px vat">
						3 Nights / 4 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Goa City</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat"><span class="dif">On Request</span></td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.saisaharatravels.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Hotel Le Seasons:  3N/4D Package - 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="119371"/>
						</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_10/270877/193326.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_10/270877/193326.jpg"  width="150" height="150"    alt="Hotel Le Seasons:  3N/4D Package" title="Hotel Le Seasons:  3N/4D Package" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Both way transfer from the Airport or Thivim Railway Station/Bus stop by sharing A/C Coach OR Car.<br />
Welcome drinks on arrival (Non-Alcoholic).<br />
Accommodation in well appointed air-conditioned room with Satellite Connection LCD TV, and Telephone.<br />
Mini Bar in room on chargeable basis.<br />
Buffet/TDH menu as per the plan selected.<br />
Complimentary use of Tea/Coffee maker in all rooms, replenished once a day. Additional requirement will be at an extra cost.<br />
Child below 5 years complimentary on plan.<br />
Complimentary 02 bottles of mineral water, replenished daily.<br />
1 day Sightseeing Tour of South Goa by A/C Coach. Rs.300/- per person Extra for Boat cruise (Boat cruise subject to weather conditions).<br />
Wi-Fi connectivity on complimentary basis for browsing only.<br />
10% Discount on DELTIN ROYALE CASINO (Subject to Availability with Terms & Conditions)<br />
Complimentary use of Swimming Pool (with proper swim wear).<br />
All applicable government Taxes.All personal expenses, optional tours and extra meals<br />
Vehicle service will be strictly as per itinerary<br />
Medical and travel insurance<br />
Anything not mentioned under ‘Inclusions’<br />
Air Fare/ Train Fare / Bus Fare<br />
Items of personal nature like tips, laundry, telephone, beverages etc<br />
Entrance fee / Local Guide / at any place during the tour<br />
Meals not mentioned in the “Inclusions” section.<br />
Anything not mentioned in the package includes section.<br />
Additional sightseeing or usages of vehicle not mentioned in the itinerary<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> Goa Tour
								</p>
								<p class="aj">Welcome drink(Non-Alcholic ) <br />
Deluxe room on twin sharing basis<br />
Meal Plan as per mentioned plan</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> 
								</p>
								<p class="aj">Day Tour</p>					
									<p><b>Meals : </b> Breakfast</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> 
								</p>
								<p class="aj">North Goa Tour</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> 
								</p>
								<p class="aj">Deaparture</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>
												</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>All personal expenses, optional tours and extra meals</li><li>
Vehicle service will be strictly as per itinerary</li><li>
Medical and travel insurance</li><li>
Anything not mentioned under ‘Inclusions’</li><li>
Air Fare/ Train Fare / Bus Fare</li><li>
Items of personal nature like tips, laundry, telephone, beverages etc</li><li>
Entrance fee / Local Guide / at any place during the tour</li><li>
Meals not mentioned in the “Inclusions” section.</li><li>
Anything not mentioned in the package includes section.</li><li>
Additional sightseeing or usages of vehicle not mentioned in the itinerary</li></ul><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>~^#^~~^#^~<p><strong>Please Note:</strong>

<ul>
	<li>Early check-in or late check-out is strictly subject to availability of rooms and on Chargeable basis and sole discretion of hotel.</li>
	<li>Extension of stay available on pro-rata basis.</li>
	<li>02 nights package available @ 85% of the above packages(3night/4days)</li>
	<li>Packages can be extended on pro rata basis.</li>
	<li>As Per Hotel&rsquo;s Applicable Terms &amp; Conditions.</li>
	<li>Late night pickup/Drop charges Rs.500/- extra.</li>
	<li>The following charges will be applicable on extra If the following sightseeing is arranged by A/C Innova Car.</li>
	<li>(North Goa sightseeing &ndash; Rs.3000/- &amp;&nbsp; South Goa sightseeing &ndash; Rs.4000/-)</li>
</ul>						
    	<div class="otherDetails aj"> Note: Hotel and rooms are subject to availability.</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">PLAN</td>
				<td class="headHr p5px b">SUPERIOR ROOM</td>
				<td class="headHr p5px b">Extra Adult</td>
				<td class="headHr p5px b">Child           (6-12 Yrs)</td>
				<td class="headHr p5px b">PREMIER ROOM</td>
				<td class="headHr p5px b">Extra Adult</td>
				<td class="headHr p5px b">Child             (6-12 Yrs)</td>
			</tr>
			<tr>
				<td class="data p5px">CPAI</td>
				<td class="data p5px">Rs.24,000/-</td>
				<td class="data p5px">7200</td>
				<td class="data p5px">4800</td>
				<td class="data p5px">Rs.26,000/-</td>
				<td class="data p5px">7800</td>
				<td class="data p5px">5200</td>
			</tr>
			<tr>
				<td class="data p5px">MAPAI</td>
				<td class="data p5px">Rs.26,000/-</td>
				<td class="data p5px">7800</td>
				<td class="data p5px">5200</td>
				<td class="data p5px">Rs.28,000/-</td>
				<td class="data p5px">8400</td>
				<td class="data p5px">5600</td>
			</tr>
			<tr>
				<td class="data p5px">APAI</td>
				<td class="data p5px">Rs.28,000/-</td>
				<td class="data p5px">8400</td>
				<td class="data p5px">5600</td>
				<td class="data p5px">Rs.30,000/-</td>
				<td class="data p5px">9000</td>
				<td class="data p5px"></td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Hotel Le Seasons -     HONEYMOON INCLUSIONS</p>
    	<div class="otherDetails aj"> <br>
For honeymoon package we have separate options that can be added to our regular packages inclusions.</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Honeymoon Décor</td>
				<td class="headHr p5px b">@ Rs.2500/- (flowers/balloons/cookie plate + 2 glasses of flavored milk or 2 mock tails</td>
			</tr>
			<tr>
				<td class="data p5px">Chocolate Cake ½ kg</td>
				<td class="data p5px">@ Rs.600/-</td>
			</tr>
			<tr>
				<td class="data p5px">Candlelight Dinner</td>
				<td class="data p5px">@ Rs.1500/- + Tax per couple : Pool side (with Fixed Indian Menu – No Seafood)</td>
			</tr>
		</table></div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.saisaharatravels.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Hotel Le Seasons:  3N/4D Package - 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="119371"/>
						</form>
						</div>
						
						";i:1;s:72:"Book Hotel Le Seasons:  3N/4D Package - 3 Nights / 4 Days Tour Packages";i:2;s:129:"book hotel le seasons:  3n/4d package - 3 nights / 4 days tour packages, beach and islands tour packages, goa city tour packages";i:3;s:172:"Sai Sahara Tours & Travels offers Hotel Le Seasons:  3N/4D Package - 3 Nights / 4 Days tour package, budget Beach and Islands tour packages for Goa City at exciting price.";i:4;s:1887:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Goa City"        
		                 },
		      "description": "Both way transfer from the Airport or Thivim Railway Station/Bus stop by sharing A/C Coach OR Car.
Welcome drinks on arrival (Non-Alcoholic).
Accommodation in well appointed air-conditioned room with Satellite Connection LCD TV, and Telephone.
Mini Bar in room on chargeable basis.
Buffet/TDH menu as per the plan selected.
Complimentary use of Tea/Coffee maker in all rooms, replenished once a day. Additional requirement will be at an extra cost.
Child below 5 years complimentary on plan.
Complimentary 02 bottles of mineral water, replenished daily.
1 day Sightseeing Tour of South Goa by A/C Coach. Rs.300/- per person Extra for Boat cruise (Boat cruise subject to weather conditions).
Wi-Fi connectivity on complimentary basis for browsing only.
10% Discount on DELTIN ROYALE CASINO (Subject to Availability with Terms & Conditions)
Complimentary use of Swimming Pool (with proper swim wear).
All applicable government Taxes.All personal expenses, optional tours and extra meals
Vehicle service will be strictly as per itinerary
Medical and travel insurance
Anything not mentioned under ‘Inclusions’
Air Fare/ Train Fare / Bus Fare
Items of personal nature like tips, laundry, telephone, beverages etc
Entrance fee / Local Guide / at any place during the tour
Meals not mentioned in the “Inclusions” section.
Anything not mentioned in the package includes section.
Additional sightseeing or usages of vehicle not mentioned in the itinerary",
		      "name": "Hotel Le Seasons:  3N/4D Package",
		      "telephone": "+91-9623788906"
		    }
		    </script>
			";i:5;N;}