a:6:{i:0;s:24230:"				<div class="h1"><h1>Amazing Gujrat - Spiritual with Wildlife Journey Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.sunbirdjourney.in/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.sunbirdjourney.in/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Amazing Gujrat - Spiritual with Wildlife Journey Tour</p>
				<br />
				
								
						<script language="javascript"> 
							function topDestinationToggle(showHideDiv, switchTextDiv) {
							var ele = document.getElementById(showHideDiv);
							var text = document.getElementById(switchTextDiv);
							if(ele.style.display == "block") {
								ele.style.display = "none";
							  text.innerHTML = "View More &#9660;";
							}
							else {
							  ele.style.display = "block";
							  text.innerHTML = "View Less &#9650;";
							}
							}
		                </script>
											<script type="text/javascript">			
					(function($){	
					  $(function(){
						$('[id^=detailslider]').each(function(){
							$(this).DG_Slider({
								auto: true, mode:'fade', pager:true, pagerType:'short',controls:true
							});
						})
				
						$('a[rel=gall]').fancybox()
					  });	
					}(jQuery))
					</script>
					
					<br />
					<div class="data">
					<table class="w100 formTable bdr0 imgWidth">
					<tr>
					<td class="p10px">
					<table class="w100 packageForm">
											<tr>
						<td class="b p5px w125px vat">Tour Code </td>
						<td class="p5px pl0px vat">SBJ.T.0016</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						7 Nights / 8 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Ahmedabad, Bhavnagar, Rajkot, Dwarka, Diu</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 22500 Per Person						</td>
						</tr>
												<tr>
						<td class="b p5px dif w125px vat">Special Offer </td>
						<td class="p5px pl0px dif vat">Contact for best Group rate</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.sunbirdjourney.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Amazing Gujrat - Spiritual with Wildlife Journey Tour - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>
						<a href="#" onclick="document.getElementById('frmpackagedetail').submit();" class="button p7px pl12px pr12px c5px b large dib mt10px">Book Your Tour</a>
						<input type="hidden" name="pkg_slno" value="51337"/>
						</form>
						</p>
						</td>
						</tr>
											</table>
					</td>
											<td class="p10px vat imgWidth150 w150px lh0">
						<div class="demo-wrap">
						<ul class="lsn m0px p0px" id="detailslider1">
															<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205613.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205613.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
																		<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205612.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205612.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
																		<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205611.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205611.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
																		<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205610.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205610.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
																		<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205609.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205609.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
																		<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205608.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205608.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
																		<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205607.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205607.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
																		<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205606.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205606.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
																		<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205605.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205605.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
																		<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/101370.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/101370.jpg"  width="150" height="150"    alt="gujrat" title="gujrat" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					The state of Gujarat is in the Western India region of the India. Lothal, near to Ahmedabad and Dholavira, near to Kutch are sites of a Harappan (Indus) civilisation, which were older than 4000 years. Gujarat is known for the Stepped Wells, Jain Temples, Asiatic Lion and business oriented people.<br />
<br />
Ahmedabad is the only International Airport in Gujarat with regular flights to and from London, New York, Chicago, Singapore, Muscat, Kuwait, Doha Qatar, Sharjah and Dubai.Domestically, travellers can be coming from hubs such as Mumbai, Delhi, Chennai, Hyderabad, Bhopal, Indore, Kolkata. Flights into smaller airports of Baroda, Bhavnagar Bhuj, Diu, Jamnagar, Porbandar, Keshod, Kandla, Surat and Rajkot will connect through Mumbai.<br />
<br />
Ahmedabad, Vadodara, Surat, Rajkot, Bhavnagar, Bhuj, Jamnagar, Junagadh, Surendranagar, Porbandar, Kandla are Big Station to access Indian Rail Network.Contact for best Group rateGST.<br />
Room incidentals.<br />
Airfare/Train fare<br />
Any major meals<br />
Horse ride/pony ride/helicopter ticket<br />
Tipping/gratuities to guide/driver.<br />
Beverages during meal time.<br />
All entrance fees where ever applicable.<br />
Camera & Video permits. <br />
Any services not mentioned in the above.01-0520-12<br />						<div class="headHr">
			            <p class="p7px b pl10px xlarge">Tour Itinerary</p>
			            </div>
			            
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 1:</b> Arrive Dwarka
								</p>
								<p class="aj">Upon arrival at Dwarka railway station / Jamnagar , meet our representative and transfer to Hotel at Dwarka<br />
Check in to the hotel<br />
Dinner & overnight stay at hotel</p>					
									<p><b>Meals : </b> Dinner</p>
								</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 <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205605.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205605.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
									</ul>
									</div>
									</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> Dwarka - Somnath(Approx. 230Km/4Hrs)
								</p>
								<p class="aj">Breakfast at hotel<br />
After breakfast check out from hotel and proceed for Dwarka sightseeing.<br />
Dwarka Local Sightseeing (Bet Dwarka, NageshwarJyotirlings, Rukmini Temple Etc), DwarkadishAartiDarshanIn Evening &<br />
Dwarka also spelled Dvarka, Dwaraka, and Dvaraka, is a city and a municipality of Jamnagar district in the Gujarat state in India. Dwarka (Dvaraka in Sanskrit - used in this article when referring to the city in a historical context), also known as Dwarawati in Sanskrit literature is rated as one of the seven most ancient cities in the country. The legendary city of Dvaraka was the dwelling place of Lord Krishna. It is believed that due to damage and destruction by the sea, Dvaraka has submerged six times and modern day Dwarka is therefore the seventh such city to be built in the area.<br />
Transfer to Somnath via Pobandar.<br />
Check in to the hotel at Somnath. Dinner & overnight stay at hotel</p>					
									<p><b>Meals : </b> Breakfast & Dinner</p>
								</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 <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205606.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205606.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
									</ul>
									</div>
									</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> Somnath (Excursion Trip To Diu Approx. 85Km/1Hr 40Mins )
								</p>
								<p class="aj">After breakfast drive to Diu on A sea cost available the best beach of Gujarat. On arrival check in at a Hotel & Full day enjoy the beach activity Overnight stay at Diu.<br />
Diu is a city in Diu district in the union territory of Daman and Diu, India. It was the location of the pivotal Battle of Diu in 1509 between Portugal and a combined force of Turkey, Egypt, Venice, the Republic of Ragusa (now known as Dubrovnik) and the then Sultan of Gujarat, Mahmud Begada. Diu District is an island lying off the south coast of Gujarat Kathiawar peninsula, separated from the mainland by a tidal creek. It has an area of 40 km², and a population of 44,110 (2001 census). The town of Diu lies at the eastern end of the island, and is known for its fortress and old Portuguese Cathedral. It is also a fishing town. The village of Ghoghla, which lies on the mainland opposite the eastern end of the island, is also part of the union territory. Note that in Google Maps you can find Diu with the name of Dangarvadi.<br />
Back to Hotel. Dinner & overnight stay at hotel</p>					
									<p><b>Meals : </b> Breakfast & Dinner</p>
								</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 <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205607.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205607.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
									</ul>
									</div>
									</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> Somnath - Rajkot (Approx. 195Km/3Hrs 15Mins)
								</p>
								<p class="aj">After breakfast check out from Hotel and transfer to Rajkot via Sasangir. Drive to visit SasanGir (45 Km). An Asiatic Lions of Gir National Park, Evening visit the Lion Sanctuary (Jeep safari Optional). Overnight stay at Somnath.<br />
SasanGir Lion Sanctuary, which lies on the southwestern fringes of the Saurashtra Peninsula (west-central India), is the last home of some 300 Asiatic lions. It was created in 1913 to protect the largest surviving groups of the Asiatic lions. It was given a sanctuary status in 1965. The vegetation in the area consists of teak with a mixture of deciduous trees, including sal (Shorea), dhak (Buteafrondosa), and thorn forests. A few springs also exist, but their flow is rather eccentric depending upon the season. Gir Forest is today the only place in the world outside Africa, where the lion can be seen in his natural habitat.<br />
Check in to the hotel at Rajkot, Dinner & overnight stay at hotel.</p>					
									<p><b>Meals : </b> Breakfast & Dinner</p>
								</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 <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205608.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205608.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
									</ul>
									</div>
									</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 5:</b> Rajkot - Bhavnagar (Approx. 175Km/3Hrs 30Mins)
								</p>
								<p class="aj">Breakfast at hotel. After check out from hotel proceed for Rajkot sightseeing - Aji dam, Ishwariya Temple, Swami Narayan temple. Rajkot was founded in the year 1610 A.D. by Chief VibhajiJadeja&RajuSandhi. Rajkot was once the capital of the princely state of Saurashtra.<br />
Dinner & overnight stay at hotel.</p>					
									<p><b>Meals : </b> Breakfast & Dinner</p>
								</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 <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205609.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205609.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
									</ul>
									</div>
									</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 6:</b> Bhavnagar - Ahmedabad (Approx. 170Km/3Hrs 15Mins)
								</p>
								<p class="aj">After breakfast check out from hotel and transfer to Ahmedabad. On the way visit Bhavnagar local sightseeing - Bhavnagar is known for Gandhi Smriti, an institution built in memory of Mahatma Gandhi, the Barton Museum, the Central Salt and Marine Research Institute,Takhteswar temple and Gauri-Shankar lake. Check in to the Hotel at Ahmedabad.<br />
Dinner & overnight stay at hotel.</p>					
									<p><b>Meals : </b> Breakfast & Dinner</p>
								</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 <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205610.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205610.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
									</ul>
									</div>
									</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 7:</b> Ahmedabad
								</p>
								<p class="aj">Breakfast at hotel<br />
Proceed for Ahmedabad local sightseeing.<br />
Evening free for shopping.<br />
Dinner & overnight stay at hotel.</p>					
									<p><b>Meals : </b> Breakfast & Dinner</p>
								</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 <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205611.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205611.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
									</ul>
									</div>
									</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 8:</b> Depart Ahmedabad
								</p>
								<p class="aj">After breakfast check out from hotel and transfer to Ahmedabad Railway station / airport.</p>					
									<p><b>Meals : </b> Breakfast</p>
								</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 <? echo $p_class; ?>"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/377396/205612.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/377396/205612.jpg"  width="150" height="150"    alt="Amazing Gujrat - Spiritual with Wildlife Journey Tour" title="Amazing Gujrat - Spiritual with Wildlife Journey Tour" /></a></p></div></li>
									</ul>
									</div>
									</td>
								</tr>
								</table>					
								</div>						<br />
												 <p class="headHr p7px b pl10px xlarge">Tour Detail</p>
			             <div class="data p15px aj">
										
						<p class="large b mb5px dif">Inclusions :</p>
						<ul>
															<li>Hotel</li>
																		<li>2 Star Hotel</li>
																		<li>3 Star Hotel</li>
																		<li>Flights</li>
																		<li>Meals</li>
																		<li>Sightseeing</li>
																		<li>Transport</li>
																		<li>Transfers</li>
																		<li>Airport Pickup-Drop</li>
																		<li>Private Cab</li>
																		<li>Stay Included</li>
																		<li>Veg & Non Veg Meals</li>
																		<li>Pickup-Drop</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>GST.</li><li>
Room incidentals.</li><li>
Airfare/Train fare</li><li>
Any major meals</li><li>
Horse ride/pony ride/helicopter ticket</li><li>
Tipping/gratuities to guide/driver.</li><li>
Beverages during meal time.</li><li>
All entrance fees where ever applicable.</li><li>
Camera & Video permits. </li><li>
Any services not mentioned in the above.</li></ul><br />
												<p class="large b mb5px dif">Specific Departure Dates :</p>Any Date<br />
												<p class="large b mb5px dif">Departure Cities with rates :</p>Any City in India<br /><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>* Some Advance Percentage of total booking amount * Airfare/Transport fare to be paid full at one time in advance.~^#^~* Upon cancellation, refund will be made after deducting the Retention Amount. * Retention Amount varies as per the number of days left before your package start date. ~^#^~												</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.sunbirdjourney.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Amazing Gujrat - Spiritual with Wildlife Journey Tour - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>
						<a href="#" onclick="document.getElementById('frmpackagedetail').submit();" class="button p7px pl12px pr12px c5px b large dib mt10px">Book Your Tour</a>
						<input type="hidden" name="pkg_slno" value="51337"/>
						</form>
						</div>
						
						";i:1;s:92:"Book Amazing Gujrat - Spiritual with Wildlife Journey Tour - 7 Nights / 8 Days Tour Packages";i:2;s:184:"book amazing gujrat - spiritual with wildlife journey tour - 7 nights / 8 days tour packages, wildlife and nature tour packages, ahmedabad, bhavnagar, rajkot, dwarka, diu tour packages";i:3;s:216:"Sunbird Journey offers Amazing Gujrat - Spiritual with Wildlife Journey Tour - 7 Nights / 8 Days tour package, budget Wildlife and Nature tour packages for Ahmedabad, Bhavnagar, Rajkot, Dwarka, Diu at exciting price.";i:4;s:1668:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Ahmedabad, Bhavnagar, Rajkot, Dwarka, Diu"        
		                 },
		      "description": "The state of Gujarat is in the Western India region of the India. Lothal, near to Ahmedabad and Dholavira, near to Kutch are sites of a Harappan (Indus) civilisation, which were older than 4000 years. Gujarat is known for the Stepped Wells, Jain Temples, Asiatic Lion and business oriented people.

Ahmedabad is the only International Airport in Gujarat with regular flights to and from London, New York, Chicago, Singapore, Muscat, Kuwait, Doha Qatar, Sharjah and Dubai.Domestically, travellers can be coming from hubs such as Mumbai, Delhi, Chennai, Hyderabad, Bhopal, Indore, Kolkata. Flights into smaller airports of Baroda, Bhavnagar Bhuj, Diu, Jamnagar, Porbandar, Keshod, Kandla, Surat and Rajkot will connect through Mumbai.

Ahmedabad, Vadodara, Surat, Rajkot, Bhavnagar, Bhuj, Jamnagar, Junagadh, Surendranagar, Porbandar, Kandla are Big Station to access Indian Rail Network.Contact for best Group rateGST.
Room incidentals.
Airfare/Train fare
Any major meals
Horse ride/pony ride/helicopter ticket
Tipping/gratuities to guide/driver.
Beverages during meal time.
All entrance fees where ever applicable.
Camera & Video permits. 
Any services not mentioned in the above.01-0520-12",
		      "name": "Amazing Gujrat - Spiritual with Wildlife Journey Tour",
		      "telephone": "91-9038012283"
		    }
		    </script>
			";i:5;N;}