a:6:{i:0;s:7062:"				<div class="h1"><h1>Vaishali-Kesariya Trip Package</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>Vaishali-Kesariya Trip 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">
						1 Day 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Patna, Vaishali, Kesariya</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="Vaishali-Kesariya Trip 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="95927"/>
						</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/162896.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/444380/162896.jpg"  width="150" height="150"    alt="Vaishali-Kesariya Trip Package" title="Vaishali-Kesariya Trip Package" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Vaishali was a city in Bihar, India, and is now an archeological site. It was the capital city of the Licchavi. It was here in 599 BCE the 24th Jain Tirthankara, Bhagwan Mahavira was born and brought up in Kundalagrama in Vaishali republic, which makes it a pious and auspicious pilgrimage to Jains. It contains one of the best-preserved of the Pillars of Ashoka, topped by a single Asiatic lion.<br />
Ancient Kesariya was called Kesaputta and was a republic ruled by Kalamas, which was later annexed by its monarchical neighbour Kosala. Alara Kalama, the teacher of Buddha before enlightenment, is said to belong to Kesaputta. Buddha is also said to have had direct connection with Kesaputta.<br />
<br />
One Meal<br />
Transfer in the city by Cab/bus<br />
One Mineral Water/Day<br />
Parking and Toll tax<br />
<br />
Sightseeing Summary :<br />
Viswa Shanti Stupa<br />
Ashoka's Pillar<br />
Abhishek Pushkarni<br />
Bawan Pokhar Temple<br />
Kundalpur<br />
Raja Vishal's Garh<br />
Choumukhi Mahadev <br />
Largest Historical Stupa of KesariyaMeals & 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 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">As soon as Guest arrives, journey will be began for Gaya (Bodh-Gaya)which will includes different sightseeing like Viswa Shanti Stupa, Ashoka's Pillar, Abhishek Pushkarni, Raja Vishal's Garh, Choumukhi Mahadev, Largest Historical Stupa of Kesariya.<br />
Guests will have their lunch at Vaishali and later they will move for further sightseeing at keshariya. After completion of all sightseeing guests will move back for Patna.</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>Sightseeing</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 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="Vaishali-Kesariya Trip 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="95927"/>
						</form>
						</div>
						
						";i:1;s:58:"Book Vaishali-Kesariya Trip Package - 1 Days Tour Packages";i:2;s:123:"book vaishali-kesariya trip package - 1 days tour packages, heritage tour packages, patna, vaishali, kesariya tour packages";i:3;s:183:"Yadav Travels (A Unit of Yadavlink Pvt Ltd) offers Vaishali-Kesariya Trip Package - 1 Days tour package, budget Heritage tour packages for Patna, Vaishali, Kesariya at exciting price.";i:4;s:1623:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Patna, Vaishali, Kesariya"        
		                 },
		      "description": "Vaishali was a city in Bihar, India, and is now an archeological site. It was the capital city of the Licchavi. It was here in 599 BCE the 24th Jain Tirthankara, Bhagwan Mahavira was born and brought up in Kundalagrama in Vaishali republic, which makes it a pious and auspicious pilgrimage to Jains. It contains one of the best-preserved of the Pillars of Ashoka, topped by a single Asiatic lion.
Ancient Kesariya was called Kesaputta and was a republic ruled by Kalamas, which was later annexed by its monarchical neighbour Kosala. Alara Kalama, the teacher of Buddha before enlightenment, is said to belong to Kesaputta. Buddha is also said to have had direct connection with Kesaputta.

One Meal
Transfer in the city by Cab/bus
One Mineral Water/Day
Parking and Toll tax

Sightseeing Summary :
Viswa Shanti Stupa
Ashoka's Pillar
Abhishek Pushkarni
Bawan Pokhar Temple
Kundalpur
Raja Vishal's Garh
Choumukhi Mahadev 
Largest Historical Stupa of KesariyaMeals & 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 fare.",
		      "name": "Vaishali-Kesariya Trip Package",
		      "telephone": "91-8292393528"
		    }
		    </script>
			";i:5;N;}