a:6:{i:0;s:7828:"				<div class="h1"><h1>Patna Darshan Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.yadavtravels.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.yadavtravels.com/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Patna Darshan 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">Duration </td>
						<td class="p5px pl0px vat">
						1 Nights / 2 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Patna</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.yadavtravels.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Patna Darshan 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="95923"/>
						</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_15/444380/162892.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/444380/162892.jpg"  width="150" height="150"    alt="Patna Darshan Tour" title="Patna Darshan Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					The Ancient city of Patna was known as Pataliputra during the Maurya period and was the capital of the Magadha Empire. Today Patna is the capital and largest city of Bihar state and situated on the southern bank of the Ganges river and home to many tourist attractions along with pilgrim centres of Buddhist, Hindu,Sikhs,Islam and Jain. Tourist attraction of Patna includes Kumhrar, Kargil Chowk War memorial, Shitla Mata Temple, Biscomaun Bhawan,Gurdwara Gobind Ghat, Chiriyatand Flyover, Bhootnath Road TV Tower,  and Mahatma Gandhi Setu.   <br />
<br />
 <br />
Takht Shri Harmandir Sahib	   <br />
Patan Devi	   <br />
Maa Shitla Mandir Agamkua	   <br />
Funtasia Park (Water Park)	   <br />
Mahavir Mandir	   <br />
Dargah Shariff (Maner)	   <br />
Sanjay Gandhi Jaivik Udhyan	   <br />
Buddha Smriti Park	   <br />
Revolving Restaurent	   <br />
Gandhi Statue (Gandhi Maidan)	   <br />
Raj Bhawan	   <br />
Sahid Smarak	   <br />
Ganga Aarti (Gandhi Ghat)	 <br />
Room charges (with twin sharing)<br />
One breakfast & One Meal<br />
Local transfer in the city by Cab<br />
One Mineral Water/Day<br />
<br />
Day1. Arrival at Patna and check-in to Hotel. Later move on a sightseeing tour of Patna<br />
Day2. Guest will take breakfast and Check-out from HotelMeals & drinks other than specified in inclusions.<br />
Expenses of personal nature such as portages, tips, telephone calls, laundry expenses etc.<br />
All entrances, guide charges & camera fees.<br />
Insurance Cover.<br />
Any air/train/bus fare.<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> Arrival
								</p>
								<p class="aj">On arriving in Patna, get received, assisted and transferred by our tour representative to get checked into your pre booked hotel. Take a rest for a while at your hotel. After this get ready to visit the different sights of Patna. <br />
Patna is known for its tourist destinations and people across the state and abroad visits Patna. Patna is the state capital of Bihar. Bihar has been home of religious leaders like Gautama Buddha, Lord Mahavir and Guru Gobind Singh and therefore of pilgrimage importance. <br />
After visiting different locations lunch will be offered and then again move for sight visit.<br />
Come back to the hotel after seeing all the sights and stay overnight.</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> Departure
								</p>
								<p class="aj">Guests will have their Breakfast and check-out from the hotel.</p>
								</td>
								</tr>
								</table>					
								</div>						<br />
												 <p class="headHr p7px b pl10px xlarge">Tour Detail</p>
			             <div class="data p15px aj">
										
						<p class="large b mb5px dif">Inclusions :</p>
						<ul>
															<li>Hotel</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Meals & drinks other than specified in inclusions.</li><li>
Expenses of personal nature such as portages, tips, telephone calls, laundry expenses etc.</li><li>
All entrances, guide charges & camera fees.</li><li>
Insurance Cover.</li><li>
Any air/train/bus fare.</li></ul><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.yadavtravels.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Patna Darshan 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="95923"/>
						</form>
						</div>
						
						";i:1;s:57:"Book Patna Darshan Tour - 1 Nights / 2 Days Tour Packages";i:2;s:102:"book patna darshan tour - 1 nights / 2 days tour packages, heritage tour packages, patna tour packages";i:3;s:162:"Yadav Travels (A Unit of Yadavlink Pvt Ltd) offers Patna Darshan Tour - 1 Nights / 2 Days tour package, budget Heritage tour packages for Patna at exciting price.";i:4;s:1779:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Patna"        
		                 },
		      "description": "The Ancient city of Patna was known as Pataliputra during the Maurya period and was the capital of the Magadha Empire. Today Patna is the capital and largest city of Bihar state and situated on the southern bank of the Ganges river and home to many tourist attractions along with pilgrim centres of Buddhist, Hindu,Sikhs,Islam and Jain. Tourist attraction of Patna includes Kumhrar, Kargil Chowk War memorial, Shitla Mata Temple, Biscomaun Bhawan,Gurdwara Gobind Ghat, Chiriyatand Flyover, Bhootnath Road TV Tower,  and Mahatma Gandhi Setu.   

 
Takht Shri Harmandir Sahib	   
Patan Devi	   
Maa Shitla Mandir Agamkua	   
Funtasia Park (Water Park)	   
Mahavir Mandir	   
Dargah Shariff (Maner)	   
Sanjay Gandhi Jaivik Udhyan	   
Buddha Smriti Park	   
Revolving Restaurent	   
Gandhi Statue (Gandhi Maidan)	   
Raj Bhawan	   
Sahid Smarak	   
Ganga Aarti (Gandhi Ghat)	 
Room charges (with twin sharing)
One breakfast & One Meal
Local transfer in the city by Cab
One Mineral Water/Day

Day1. Arrival at Patna and check-in to Hotel. Later move on a sightseeing tour of Patna
Day2. Guest will take breakfast and Check-out from HotelMeals & drinks other than specified in inclusions.
Expenses of personal nature such as portages, tips, telephone calls, laundry expenses etc.
All entrances, guide charges & camera fees.
Insurance Cover.
Any air/train/bus fare.",
		      "name": "Patna Darshan Tour",
		      "telephone": "91-8292393528"
		    }
		    </script>
			";i:5;N;}