a:6:{i:0;s:7674:"				<div class="h1"><h1>Chail - Kufri - Fagu - Shimla Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.kirtytours.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.kirtytours.com/holiday-packages.htm" title="Holiday Packages">Holiday Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Chail - Kufri - Fagu - Shimla Tour</p>
				<br />
				
									<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>
					
					<table class="w100 formTable imgWidth">
					<tr>
					
											<td class="p10px vat imgWidth150 w150px">
						<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_1/4147/171982.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_1/4147/171982.jpg"  width="150" height="150"    alt="Chail - Kufri - Fagu - Shimla Tour" title="Chail - Kufri - Fagu - Shimla Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											
					<td class="p10px">
											<p class="mb5px"><b>Duration :</b> 
						3 Nights / 4 Days 
						</p>
												<p class="mb5px"><b>Destination Covered :</b> Chail, Kufri, Shimla, Fagu</p>
												<p><b>Price (Starting From) :</b> <span class="dif">On Request</span></p>
												<br />
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.kirtytours.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Chail - Kufri - Fagu - Shimla Tour - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>
						<a href="#" onclick="document.getElementById('frmpackagedetail').submit();" class="buttonBig p10px20px c5px b large dib">Book Your Tour</a>
						<input type="hidden" name="pkg_slno" value="502"/>
						</form>
						</p>
											</td>
					</tr>
					</table>
										<br />
					
					<div class="packageTabs myTabs horizontal mc"><!--MY TABS STARTS-->
					<ul class="fo lsn m0px p0px">
					
											<li id="tab2"><a href="#data2">Itinerary</a></li>
												<li id="tab4"><a href="#data4">Tour Detail</a></li>
												<li id="tab5"><a href="#data5">Rate Card</a></li>
												<li id="tab6"><a href="#data6">Terms &amp; Conditions</a></li>
											</ul>
					
					
											<div class="ic bdr" id="data2"><!--DATA2 START-->
						<br />
						<ul class="lsn m0px p0px">
									<li>
									<p class="b mb5px">Day 1: Chail
									</p>
									<div class="data p10px">Nestling in the shelter of virgin forests that cover many un-toddle hills, Chail (2226m) is a tiny resort in the Sivalik region of Himachal Pradesh. Happily isolated from the rest of Himachal, Chail is a  place where time stands still, nature is at her exuberant best and words like pollution and deforestation have never entered  the dictionary of people living here. Chail has interesting history. Originally, it was a part of Keonthal State. Then it came under the sway of the Gorkha warrior Amer Singh. Finally, it became a royal resort and summer seat of Maharaja Patiala.</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 2: Chail
									</p>
									<div class="data p10px">Visit Highest Cricket Ground  (3 kms) : Built in 1893, after leveling the top of hill, this stands at 2444 m and is the highest cricket pitch in the world.<br />
<br />
Visit Sidh Baba Temple (3 kms):  Maharaja Bhupinder Singh originally began  building his Palace at this site. It is said  that a Sidh, saintly person appeared before the Maharaja in a dream and declared that this was the place where he had meditated, Bhupinder Singh shifted his Palace and also had this temple built.</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 3: Fagu - Kufri
									</p>
									<div class="data p10px">After breakfast proceed to Peach Blossom-Fagu for over night stay.<br />
<br />
On way see Rhododendron Flower Tree (State Flower) and lunch at Café Lalit, Kufri.<br />
<br />
Visit Himlayan National Park, Kufri which has several animals of the area including bears and musk deers.<br />
<br />
Visit the Mahasu Peak : Rises above Kufri and makes a good hike. The view from the top is magnificent.<br />
<br />
Fagu:<br />
Fagu is a tiny village that rest astride a mountain saddle along the Hindustan Tibet Road. The location gives it a rare range of views that encompass both its northern and southern valleys and the snow-clad peaks of the Greater Himalaya. In the open patches, the valleys hold tiny hamlets, orchards and neatly terraced fields while the area is covered with forests of Deodar (Himalayan cedar) and spruce. Exhaustively rebuilt as a deluxe resort with all modern comforts, the Hotel Peach Blossom provides a rare opportunity to enjoy nature’s serenity and magnificence.</div>					
									</li>
									<br />
									<li>
									<p class="b mb5px">Day 4: Shimla
									</p>
									<div class="data p10px">After breakfast proceed to Shimla for dropping.</div>					
									</li>
									<br />					
							</ul>						<!--DATA2 EMD--></div>
											
						<div class="ic bdr" id="data4"><!--DATA4 START-->
						<br />
													<p class="b mb5px dif">Inclusions :</p>
							<ul>
																	<li>Hotel</li>
																	</ul>
							<br />
													<!--DATA4 EMD--></div>
							
						<div class="ic bdr" id="data5"><!--DATA5 START-->
						<br />
						
    	<p class="h dif xlarge b mb5px">Hotel / Resort Provided</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Place</td>
				<td class="headHr p5px b">No. of Nights Stay</td>
				<td class="headHr p5px b">Hotel / Resort Provided</td>
			</tr>
			<tr>
				<td class="data p5px">Chail</td>
				<td class="data p5px">2</td>
				<td class="data p5px">The Palace</td>
			</tr>
			<tr>
				<td class="data p5px">Fagu</td>
				<td class="data p5px">1</td>
				<td class="data p5px">The Peach Blossom</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Package Cost</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Package</td>
				<td class="headHr p5px b">Price with Transportation  (By Car) </td>
				<td class="headHr p5px b">Price Without Transportation</td>
			</tr>
			<tr>
				<td class="data p5px">Chail - Kufri - Fagu - Shimla</td>
				<td class="data p5px">8330</td>
				<td class="data p5px">6830</td>
			</tr>
		</table></div><br>						<!--DATA5 EMD--></div>
												<div class="ic bdr" id="data6"><!--DATA6 START-->
						<br />
						* 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. ~^#^~						<!--DATA6 EMD--></div>
											
					<!--MY TABS END--></div>
					";i:1;s:73:"Book Chail - Kufri - Fagu - Shimla Tour - 3 Nights / 4 Days Tour Packages";i:2;s:137:"book chail - kufri - fagu - shimla tour - 3 nights / 4 days tour packages, valley tour packages, chail, kufri, shimla, fagu tour packages";i:3;s:190:"Book Chail - Kufri - Fagu - Shimla Tour - 3 Nights / 4 Days tour packages from Kirty Tours & Travels - Get attractive 3 Nights / 4 Days Valley  tour packages for  Chail, Kufri, Shimla, Fagu.";i:4;s:432:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Chail, Kufri, Shimla, Fagu"        
		                 },
		      "description": "",
		      "name": "Chail - Kufri - Fagu - Shimla Tour",
		      "telephone": "+91-9021222720"
		    }
		    </script>
			";i:5;N;}