a:6:{i:0;s:11942:"				<div class="h1"><h1>Bihar A Buddhist heritage Break 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>Bihar A Buddhist heritage Break 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">
						7 Nights / 8 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Gaya, Patna, Rajgir, Vaishali, Madhubani, Sonpur, Dharbhanga</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="Bihar A Buddhist heritage Break 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="95906"/>
						</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/162875.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/444380/162875.jpg"  width="150" height="150"    alt="Bihar A Buddhist heritage Break Tour" title="Bihar A Buddhist heritage Break Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Bihar, the ancient land of Buddha, has witnessed golden period of Indian history. It is the same land where the seeds of the first republic were sown and which cultivated the first crop of democracy. Such fertile is the soil that has given birth to in-numerous intellectuals which spread the light of knowledge and wisdom not only in the country but in the whole world.<br />
“Bihar- a Buddhist heritage Break Tour” package has been designed to take you on a journey through all those famous places, which are currently located in Bihar.<br />
<br />
Room charges (with twin sharing)<br />
One breakfast & One Meal<br />
Local transfer in the city by Cab<br />
One Mineral Water / DayMeals & 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 to Patna
								</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 Shri Guru Gobind Singh and therefore of pilgrimage importance.<br />
After Visiting different locations a noon lunch will be offered and then again move to the particular sight for the visit.<br />
In evening come back to the hotel and Stay overnight at the hotel.</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> Rajgir
								</p>
								<p class="aj">Guests will be starting their morning with delicious breakfast and then they will start their sight visit in their particular cab. After having half day sight-seeing they will have their meal and check out from the hotel to move to for Nalanda including pawapuri and Rajgir.<br />
Pawapuri is a holy site for Jains located in the Nalanda district in the  Bihar state of Eastern India. It is located about nineteen kilometers from Rajgir and 101 kilometers from Patna, the capital of Bihar.<br />
Nalanda is one of the greatest centers of learning in the ancient times. Nalanda is part of the Buddhist Circuit that also includes Bodh Gaya and Rajgir.<br />
Guests will Check-in their pre-Booked hotel at Rajgir and take rest before moving further.</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> Nalanda and Pawapuri
								</p>
								<p class="aj">Early morning Guests will be picking up in the cab for beautiful sightseeing of Rajgir along with that guest will have their Breakfast.<br />
From half day we will move for Nalanda and Pawapuri. In evening guests will be coming back to their hotels. They will have their delicious Dinner and stay overnight at hotel.</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> Bodh Gaya
								</p>
								<p class="aj">Starting a day with Breakfast and moving towards Bodh Gaya in the cab.<br />
After reaching at Bodh-Gaya get checked into your pre booked hotel .Take a rest for a while at your hotel and move towards sight-seeing of Bodh Gaya. <br />
Come back to the hotel in evening. Guests will have their Dinner in the hotel and stay overnight at hotel.</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 5:</b> Bodh Gaya
								</p>
								<p class="aj">We will start our day with breakfast and moving towards sight-seeing whole day in between we will provide lunch to our guests.<br />
And in evening come back to hotel 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 6:</b> Sonpur, Vaishali
								</p>
								<p class="aj">Guests will be starting their day with Delicious breakfast and then checkout from the hotel for moving towards Sonpur and Vaishali.<br />
In between we will be crossing from the Longest Bridge of Asia i.e., Mahatma Gandhi Setu Bridge.<br />
We will try to click some photographs there on the Bridge (if possible then only)<br />
After reaching at Sonpur different sites like Hariharnath Temple, Gagh-Garh Statue will be visited.<br />
And then moving towards Vaishali, after reaching their check-in into hotel and starts our journey and in evening come back to hotel, then check out from hotel for moving towards Dharbhanga Stay overnight there with enjoying the Delicious Dinner.</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 7:</b> Dharbhanga and Madhubani
								</p>
								<p class="aj">Guests will start their day with Breakfast and moving towards different sight visits of Dharbhanga and then from half day guests will move towards Madhubani for seeing Mithila Painting and other attractive locations. Guests will check-in into hotel.</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 8:</b> Departure to Patna
								</p>
								<p class="aj">Guests will be provided Break-fast and then check-out from the hotel for departure to 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>Hotel</li>
																		<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/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="Bihar A Buddhist heritage Break 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="95906"/>
						</form>
						</div>
						
						";i:1;s:75:"Book Bihar A Buddhist heritage Break Tour - 7 Nights / 8 Days Tour Packages";i:2;s:189:"book bihar a buddhist heritage break tour - 7 nights / 8 days tour packages, religious & pilgrimage tour packages, gaya, patna, rajgir, vaishali, madhubani, sonpur, dharbhanga tour packages";i:3;s:249:"Yadav Travels (A Unit of Yadavlink Pvt Ltd) offers Bihar A Buddhist heritage Break Tour - 7 Nights / 8 Days tour package, budget Religious & Pilgrimage tour packages for Gaya, Patna, Rajgir, Vaishali, Madhubani, Sonpur, Dharbhanga at exciting price.";i:4;s:1355:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Gaya, Patna, Rajgir, Vaishali, Madhubani, Sonpur, Dharbhanga"        
		                 },
		      "description": "Bihar, the ancient land of Buddha, has witnessed golden period of Indian history. It is the same land where the seeds of the first republic were sown and which cultivated the first crop of democracy. Such fertile is the soil that has given birth to in-numerous intellectuals which spread the light of knowledge and wisdom not only in the country but in the whole world.
“Bihar- a Buddhist heritage Break Tour” package has been designed to take you on a journey through all those famous places, which are currently located in Bihar.

Room charges (with twin sharing)
One breakfast & One Meal
Local transfer in the city by Cab
One Mineral Water / DayMeals & 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": "Bihar A Buddhist heritage Break Tour",
		      "telephone": "91-8292393528"
		    }
		    </script>
			";i:5;N;}