a:7:{i:0;s:85122:"				<section id="middle" class="propDtls ttwBtmFtSpace">
				<div class="wrap thinFormat " id="bodyFormatNT">
									<div class="ar small fo"><a href="https://www.rajtoursandtravels.co.in/" title="Home">Home</a>
					
											<b class="ffv p2px">&rsaquo;</b> <a href="https://www.rajtoursandtravels.co.in/packages.htm" title="Packages">Packages</a>  			
											
					<b class="ffv p2px">&rsaquo;</b> <span class="alpha75">Untouched Beauty of Kashmir Tour</span></div> 
									
				<div class="row1 dt columns23"><!--MIDDLE ROW1 STARTS-->
				<div class="col-2 wideColumn ip ls"><!--MIDDLE ROW1 COL-2 STARTS-->				
								
						<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>
				
					<div class="data mb15px mt15px p10px"> 
	 				<div class="fo dt w100"> 	 				
	 											<div class="dtc vat ttw-detail pr20px pr">
							<div class="headVr bdr0">
							<ul class="lsn gallery-slide" id="bxlider_ins">
																	<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/wh1/dir_1/27631/56010.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/wh1/dir_1/27631/56010.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/wh1/dir_1/27631/56010.jpg"  height="150"  width="150"    alt="Untouched Beauty of Kashmir Tour" title="Untouched Beauty of Kashmir Tour" ></div></a></div></div></li>
																				<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/wh1/dir_1/27631/56011.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/wh1/dir_1/27631/56011.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/wh1/dir_1/27631/56011.jpg"  height="150"  width="150"    alt="Untouched Beauty of Kashmir Tour" title="Untouched Beauty of Kashmir Tour" ></div></a></div></div></li>
																	</ul>
															<ul class="lsn" id="bxslider-pager">
																	<li data-slideIndex="0"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/wh1/dir_1/27631/56010.jpg"  height="150"  width="150"    alt="Untouched Beauty of Kashmir Tour" title="Untouched Beauty of Kashmir Tour" ></a></li>
																		<li data-slideIndex="1"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/wh1/dir_1/27631/56011.jpg"  height="150"  width="150"    alt="Untouched Beauty of Kashmir Tour" title="Untouched Beauty of Kashmir Tour" ></a></li>
																	</ul>
																<script>
								var realSlider= jQuery("ul#bxlider_ins").bxSlider({
								speed:500,
								pager:false,
								auto: true,
								slideWidth: 450,
								slideMargin: 0,
								nextText:'',
								prevText:'',
								infiniteLoop:true,
								hideControlOnEnd:true,
								onSlideBefore:function($slideElement, oldIndex, newIndex){
								changeRealThumb(realThumbSlider,newIndex);
								
								}
								
								});
								
								var realThumbSlider=jQuery("ul#bxslider-pager").bxSlider({
								minSlides: 4,
								maxSlides: 4,
								slideWidth: 115,
								slideMargin: 5,
								moveSlides: 1,
								pager:false,
								auto:false,
								speed:1000,
								infiniteLoop:false,
								hideControlOnEnd:false,
								nextText:'<span></span>',
								prevText:'<span></span>',
								onSlideBefore:function($slideElement, oldIndex, newIndex){
								
								}
								});
								
								linkRealSliders(realSlider,realThumbSlider);
								
								if(jQuery("#bxslider-pager li").length<5){
								jQuery("#bxslider-pager .bx-next").hide();
								}
								
								// sincronizza sliders realizzazioni
								function linkRealSliders(bigS,thumbS){
								
								jQuery("ul#bxslider-pager").on("click","a",function(event){
								event.preventDefault();
								var newIndex=jQuery(this).parent().attr("data-slideIndex");
								bigS.goToSlide(newIndex);
								});
								}
								
								//slider!=$thumbSlider. slider is the realslider
								function changeRealThumb(slider,newIndex){  
								var $thumbS=jQuery("#bxslider-pager");
								$thumbS.find('.active').removeClass("active");
								$thumbS.find('li[data-slideIndex="'+newIndex+'"]').addClass("active");
								
								if(slider.getSlideCount()-newIndex>=4)slider.goToSlide(newIndex);
								else slider.goToSlide(slider.getSlideCount()-4);
								
								}
								</script>
															</div>
							</div>
												<div class="dtc pt7px ttwDtlsCont">
					<div class="adrsDtls">
											<h1>Untouched Beauty of Kashmir Tour</h1>
											<div class="ShareDropdown">		
					<div class="copyLinkPopup">Link Copied</div>	  
					<span class="data"><i class="fa fa-share-alt xxlarge vam"></i></span>
					<ul class="shareList data bdr0">
					<li><a target="_blank" href="https://www.facebook.com/sharer/sharer.php?u=https://www.rajtoursandtravels.co.in/tour-packages/untouched-beautyof-kashmir-tour1.htm" class="facebook" title="Facebook"><i class="fa fa-facebook-official"></i></a></li> 
					<li><a target="_blank" href="https://www.instagram.com/?url=https://www.rajtoursandtravels.co.in/tour-packages/untouched-beautyof-kashmir-tour1.htm" class="instagram" title="Instagram"><i class="fa fa-instagram"></i></a></li>
					<li><a target="_blank" href="https://wa.me/?text=https://www.rajtoursandtravels.co.in/tour-packages/untouched-beautyof-kashmir-tour1.htm" class="whatsapp" title="Whatsapp"><i class="fa fa fa-whatsapp"></i></a></li>  
					<li><a target="_blank" href="https://twitter.com/intent/tweet?text=Untouched Beauty of Kashmir Tour&url=https://www.rajtoursandtravels.co.in/tour-packages/untouched-beautyof-kashmir-tour1.htm" class="twitter" title="Twitter"><img src="https://catalog.wlimg.com/mobile/social-networking-img/1002.svg" alt="Twitter" style="width:22px;height:22px;vertical-align:middle;margin-right:6px;"></a></li> 
					<li><a target="_blank" href="https://www.linkedin.com/shareArticle?mini=true&url=https://www.rajtoursandtravels.co.in/tour-packages/untouched-beautyof-kashmir-tour1.htm&title=Untouched Beauty of Kashmir Tour" class="linkedin" title="Linkedin"><i class="fa fa-linkedin-square"></i></a></li>
					<li><a target="_blank" href="https://pinterest.com/pin/create/button/?url=https://www.rajtoursandtravels.co.in/tour-packages/untouched-beautyof-kashmir-tour1.htm&description=Untouched Beauty of Kashmir Tour" class="pinterest" title="Pinterest"><i class="fa fa-pinterest-square"></i></a></li>
					<li><a href="javascript:;" title="Copy Link" class="copy" onclick="copyURL()"><i class="fa fa-clone"></i></a></li>
					</ul>
					</div>
					</div>
					<script>
					$(document).ready(function(){
					$('.ShareDropdown span').click(function(){
					 $('.ShareDropdown').toggleClass("active");
					}); 
					});
					</script>
					<script>
					  function copyURL() {
					    const url = window.location.href;
						const textarea = document.createElement("textarea");
						textarea.value = url;
						textarea.style.position = "fixed";
						document.body.appendChild(textarea);
						textarea.focus();
						textarea.select();
				
						try {
						  document.execCommand("copy");
						//  alert("URL copied (fallback)!");
						  $(".copyLinkPopup").show();		 
				          setTimeout(function(){$(".copyLinkPopup").hide();}, 2000);
					      $('.ShareDropdown').removeClass("active");
						  
						} catch (err) {
						  console.error("Fallback copy failed:", err);
						}
				
						document.body.removeChild(textarea);
					  }
					</script>
											<p class="mb5px"><b>Duration :</b> 
						7 Nights / 8 Days 
						</p>
												<p class="mb5px"><b>Destination Covered :</b> Jammu, Srinagar, Kashmir, Katra, Gulmarg, Sonamarg, Pahalgam, Shankaracharya Temple, Dal Lake</p>
												<p class="mb5px"><b>Tour Activities :</b> Religious & Pilgrimage</p>
												<p class="mb5px"><b>Tour Themes : </b>Religious & Pilgrimage</p>
												<div class="fo mt20px mb20px ac xxlarge">
          				<p class="xxlarge b dif mb2px">
						<i class="fa fa-inr"></i> 14499						</p>
						<p class="xxsmall alpha50">Per Person</p>
          				</div>
											<div class="ac">
					<form class="inquiry-form" name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.rajtoursandtravels.co.in/enquiry-form-10028.htm">
					<input type="hidden" name="subject" value="Untouched Beauty of Kashmir Tour - Tour Package"/>
					<input type="hidden" name="allocate_type" value="tour"/>							
					<input type="hidden" name="pkg_slno" value="28363"/>
					</form>
					<a href="javascript:;" class="submit-inquiry button p10px20px c5px ts0 xlarge dib fw6">Inquire Now for Best Deals</a>
					
										</div>
					<br />
										</div>
	   				</div>
					</div>
											<div class="mt7px dif small mb15px">* Mentioned prices may vary depending upon date of travel, hotel availability, surge pricing and seasonal rush.</div>
														<section id="s1">
								<div class="data mt20px mb20px m_p25px lh2em">      
								<div class="xxlarge mb10px">
												   					<h2 class="fw7">Jammu, Srinagar and Kashmir Tour Overview</h2>
				   													</div>
								<p class="large">					
								Any Air or Train fare and Helicopter charges. <br />
Gondola ride, Pony ride, Boating, horse riding, etc.<br />
Chandanwadi, Aru valley and Betaab Valley sightseeing at Pahalgam. <br />
Travel insurance, Medical expenses and Rescue evacuation due to mishaps.  <br />
Personal expenses such as laundry, telephone call, tips, porterages, any camera fees etc.<br />
Expenses caused by factors beyond our control like rail and flight delays, roadblocks, vehicle malfunctions, political disturbances etc.<br />
Any increase in fuel surcharge or any kind of taxes levied by the respective government or statutory bodies, the tour price will be amended in accordance..<br />
Anything which is not mentioned “ Cost Includes” <br />
3.09 % Government service tax. 								</p>
								</div>
								</section>
																<section id="s2" class="mt15px">
								<div class="data mb20px m_p25px">
		  						<div class="fw7 xxlarge">
		  										   					<h2 class="fw7">Jammu, Srinagar and Kashmir Tour Itinerary</h2>
				   							  						</div>
					            <div class="tour-details-view mt22px">
					            
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 1</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px on"><a href="javascript:;" class="clickable db"><h3>Jammu to Katra ( 56 km / 2 hours.)</h3>
										<span class="fr pr10px"><i class="fa fa-angle-up"></i></span></a>
										</div>
										<div class="pro-detail mb15px ">On arrival at the Jammu railway station, You will be met by our representative. He Will assist and  drive to Katra and transfer to your hotel. The rest of the day is at leisure.<br />
Katra is The base point of Vaishno Devi. Overnight  Stay at Katra. ( Meals: Dinner)
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 2</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Katra (Vaishnodevi)</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px dn">After breakfast proceed to the Mata Vaishnodevi Temple a trek of total 28 km by foot, Horse, Doli, Helicopter. Overnight Stay at Katra.
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 3</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Katra to Pahalgam (  270  km / 8 hours.)</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px dn">After breakfast  drive to Pahalgam “The  Valley  of  Shepherds”  situated on the  bank of  river Lidder  which is most famous place for Indian film Industry. Enjoy natural charm of the valley. Excursion to Chandanwadi for a magnificent view of Lidder valley, Aru Valley, Betaab Valley. Overnight Stay at Pahalgam.
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 4</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Pahalgam to Srinagar.( Deluxe Houseboat )  (  98  km / 3 hours.)</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px dn">After breakfast drive to Srinagar. On the way visit Saffron fields of Pampore and Avantipur ruins which is 1100 years old temple dedicated to Lord Vishnu. Avantipur was founded by the King Avantivarman and Cricket bat factory. On arrival check in at houseboat. Overnight Stay at Deluxe Houseboat.
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 5</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Srinagar ( Local sightseeing)</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px dn">After breakfast, you take a Shikara  ride on Dal Lake where you visit Nehru Park, Floating Marke. Charchinar, Mughal Gardens : Shalimar Bagh, “Abode  of Love” Nishat Bagh, ‘Garden of Pleasure’ Chashme Shahi ‘The Royal Spring’, Hazrat Bal, Shankaracharya Temple. Overnight Stay at Srinagar.
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 6</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Srinagar - Sonmarg - Srinagar(186  km / 8 hours)</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px dn">After breakfast depart to stunning Sonmarg popularly known as ‘Meadow of Gold’ situated in the Sindh Valley draped with flower beds and surrounded by stunning mountains. Enjoy a pony ride on The glacier.(On direct payment basis) Return back to your hotel.  Overnight  Stay at Srinagar.
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 7</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Srinagar - Gulmarg - Khilanmarg - Srinagar (112 km / 5 hours.)</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px dn"> After breakfast depart to Gulmarg known as 'Meadow of Flowers'. Drive through the Pine Forest. Later walk along pony trails with a magnificent view of the mountains. Gulmarg has one of the best ski slopes in the World. Golf Course. Enjoy fun filled pony ‘Gondola ride’ (direct payment basis). Overnight Stay at Srinagar.
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 8</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Departure from Jammu</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px dn">After breakfast depart to Jammu railway station to catch your train to your destination With wonderful memories of Kashmir, Tour end.
										</div> 
										</div>  
			 							</div>								</div>
								</div>
								<script>
								jQuery('.fancybox').fancybox();
								  jQuery(document).ready(function() {
								  jQuery('[data-fancybox]').fancybox({
								  thumbs : {
								  autoStart : true,
								  axis      : 'x'
								  }
								  });
								});
								</script>
								<script>
								jQuery(document).ready(function() {
								//jQuery('.tour-details-view .pro-detail').css('display','none');
								jQuery(".tour-details-view .sub-title").click(function(){
									var $this = jQuery(this);
									  jQuery('.w-title').addClass('h15px',400);
									  $this.find('.w-title').removeClass('h15px',400);
									  if($this.hasClass('on')){
										$this.removeClass('on');
										$this.next().slideUp();          	
									  } else {
										jQuery(".tour-details-view .sub-title").removeClass('on');
										jQuery('.tour-details-view .pro-detail').slideUp();
										$this.addClass('on');
										$this.next().slideDown(); 
									  }		  
									  if($this.find('.tour-details-view i').hasClass('fa-angle-up')){
										$this.find('.tour-details-view i').removeClass('fa-angle-up').addClass('fa-angle-down');
									  } else {
										$this.find('.tour-details-view i').removeClass('fa-angle-down').addClass('fa-angle-up');
									  }
									});
								});
								</script>
								</section>
															<div class="xxlarge mt10px mb10px dib">
										   					<h2 class="fw7">More Details about Jammu, Srinagar and Kashmir Tour</h2>
			   												</div>
															<section id="s3">
								<div class="data mb20px m_p25px large">
								<div class="mb7px"> 
								<p class="fw7 xxlarge mb10px dib">Inclusions</p>
								</div>
												
								<ul>
																			<li>Hotel</li>
																						<li>Sightseeing</li>
																						<li>Transfers</li>
																			</ul>
								</div>
								</section> 
																<section id="s4">
								<div class="data mb20px m_p25px large">
								<div class="mb7px"> 
								<p class="fw7 xxlarge mb10px dib">Exclusions</p>
								</div>
								
								<ul><li>Any Air or Train fare and Helicopter charges. </li><li>
Gondola ride, Pony ride, Boating, horse riding, etc.</li><li>
Chandanwadi, Aru valley and Betaab Valley sightseeing at Pahalgam. </li><li>
Travel insurance, Medical expenses and Rescue evacuation due to mishaps.  </li><li>
Personal expenses such as laundry, telephone call, tips, porterages, any camera fees etc.</li><li>
Expenses caused by factors beyond our control like rail and flight delays, roadblocks, vehicle malfunctions, political disturbances etc.</li><li>
Any increase in fuel surcharge or any kind of taxes levied by the respective government or statutory bodies, the tour price will be amended in accordance..</li><li>
Anything which is not mentioned “ Cost Includes” </li><li>
3.09 % Government service tax.</li></ul>
								</div>
								</section>
																<section id="s5">
								<div class="data mb20px m_p25px large">          
								<div class="mb7px"> 
								<p class="fw7 xxlarge mb10px dib">Rate Card</p>
								</div>
								
    	<p class="h dif xlarge b mb5px">Price Details:-</p>
    	<div class="otherDetails aj"> For travel between Sat, 15 Aug. 2014 and Tue, 20 Jan.  2015</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Category</td>
				<td class="headHr p5px b">Adult Twin sharingAdult Twin sharing</td>
				<td class="headHr p5px b">Extra Adult  Triple Sharing</td>
				<td class="headHr p5px b">Child   (With bed) Below 11yrs.</td>
				<td class="headHr p5px b">Child  (Without bed)   Below 5 yrs.</td>
				<td class="headHr p5px b">Single </td>
				<td class="headHr p5px b">Infant (Below  2yrs.)</td>
			</tr>
			<tr>
				<td class="headVr p5px">Standard</td>
				<td class="data p5px">Rs. 16,499</td>
				<td class="data p5px">Rs. 14,499</td>
				<td class="data p5px">Rs. 10,499</td>
				<td class="data p5px">Rs. 4,950</td>
				<td class="data p5px">Rs. 18,500</td>
				<td class="data p5px">Rs. 1,500</td>
			</tr>
			<tr>
				<td class="headVr p5px">Deluxe</td>
				<td class="data p5px">Rs. 20,999 </td>
				<td class="data p5px">Rs. 17,999</td>
				<td class="data p5px">Rs. 17,999</td>
				<td class="data p5px">Rs. 5,950</td>
				<td class="data p5px">Rs. 22,900</td>
				<td class="data p5px">Rs. 2,000</td>
			</tr>
			<tr>
				<td class="headVr p5px">Luxury </td>
				<td class="data p5px">Rs. 24,499</td>
				<td class="data p5px">Rs. 21,499</td>
				<td class="data p5px">Rs. 21,499</td>
				<td class="data p5px">Rs. 6,950</td>
				<td class="data p5px">Rs. 26,950</td>
				<td class="data p5px">Rs. 2,500</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Hotel  used:-</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">Nights</td>
				<td class="headHr p5px b">Standard</td>
				<td class="headHr p5px b">Deluxe</td>
				<td class="headHr p5px b">Luxury</td>
			</tr>
			<tr>
				<td class="headVr p5px">Katra</td>
				<td class="data p5px">2</td>
				<td class="data p5px">Atithi International **</td>
				<td class="data p5px">JMK International ***</td>
				<td class="data p5px">Jai Maa Inn Hotel ****</td>
			</tr>
			<tr>
				<td class="headVr p5px">Srinagar</td>
				<td class="data p5px">1</td>
				<td class="data p5px">Deluxe Houseboat</td>
				<td class="data p5px">Super Deluxe Houseboat</td>
				<td class="data p5px">Super Deluxe Houseboat</td>
			</tr>
			<tr>
				<td class="headVr p5px">Srinagar</td>
				<td class="data p5px">3</td>
				<td class="data p5px">New Prince Inn **</td>
				<td class="data p5px">Hotel Grand Habib ***</td>
				<td class="data p5px">Batra Residency ****</td>
			</tr>
			<tr>
				<td class="headVr p5px">Pahalgam</td>
				<td class="data p5px">2</td>
				<td class="data p5px">Highland Resort **</td>
				<td class="data p5px">Hotel Baisaran ***</td>
				<td class="data p5px">Hotel Mountview ****</td>
			</tr>
		</table></div><br>								</div>
								</section>
									
								<section id="s6">
								<div class="data mb20px m_p25px large">            
								<div class="mb7px"> 
								<p class="fw7 xxlarge mb10px dib">Terms &amp; Conditions</p>
								</div>				
								<ul>
	<li>
	<p align="justify" style="margin-bottom: 0in">All bookings are confirmed subject to 50% advanced payments. The balance payment is to be settled 15 days prior to departure.
	</li>
</ul>								</div>
								</section>
														<section id="s7">
						<div class="data mb20px m_p25px large res_table">            
						<div class="mb7px"> 
						<p class="fw7 xxlarge mb10px dib">Price &amp; Rates</p>
						</div>				
				        <table class="mb15px bdrall bdreee w100 p10px20px formTable">
				        	<tr class="headVr b">
			                	<th class="p15px al">No of pax</th>
			                    <th class="p15px al">Age Limit</th>
			                    <th class="p15px al">Price per pax (Rs)</th>
			                </tr>

															<tr>
				            	<td class="p15px"><span class="fw6 tblTitle">No of pax </span> Adult</td>
				                <td class="p15px"><span class="fw6 tblTitle">Age Limit </span> Above 12 years</td>
				                <td class="p15px"><span class="fw6 tblTitle">Price per pax (Rs) </span> 
			                				                		<b class="webrupee">INR</b>
			                					                	<b>14499</b> <small>/
			
			                		Adult			
			                				
			                		
			                	</small></td>
				            	</tr>
				            					         </table>
						</div>
						</section>
					 							<section id="s8">
						<div class="data mb20px m_p25px large">            
						<div class="mb7px"> 
						<p class="fw7 xxlarge mb10px dib">Packages by Theme</p>
						</div>
													<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.rajtoursandtravels.co.in/beach-islands-holidays-catid.htm" title="Beaches and Islands Tour Packages">Beaches and Islands Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.rajtoursandtravels.co.in/hill-station-holidays-catid.htm" title="Hill Stations & Valleys Tour Packages">Hill Stations & Valleys Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.rajtoursandtravels.co.in/heritage-holidays-catid.htm" title="Heritage Tour Packages">Heritage Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.rajtoursandtravels.co.in/adventure-holidays-catid.htm" title="Adventure Tour Packages">Adventure Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.rajtoursandtravels.co.in/camping-holidays-catid.htm" title="Camping Tour Packages">Camping Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.rajtoursandtravels.co.in/trekking-holidays-catid.htm" title="Trekking Tour Packages">Trekking Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.rajtoursandtravels.co.in/mountaineering-holidays-catid.htm" title="Mountaineering Tour Packages">Mountaineering Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.rajtoursandtravels.co.in/skiing-holidays-catid.htm" title="Skiing Tour Packages">Skiing Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.rajtoursandtravels.co.in/horse-riding-holidays-catid.htm" title="Horse Riding Tour Packages">Horse Riding Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.rajtoursandtravels.co.in/jeep-safari-holidays-catid.htm" title="Jeep Safari Tour Packages">Jeep Safari Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/house-boat-holidays-catid.htm" title="House Boat Tour Packages">House Boat Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/boating-holidays-catid.htm" title="Boating Tour Packages">Boating Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/museums-holidays-catid.htm" title="Museums Tour Packages">Museums Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/sightseeing-holidays-catid.htm" title="Sightseeing Tour Packages">Sightseeing Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/religious-pilgrimage-holidays-catid.htm" title="Religious & Pilgrimage Tour Packages">Religious & Pilgrimage Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/national-parks-holidays-catid.htm" title="Wildlife Sanctuaries & National Parks Tour Packages">Wildlife Sanctuaries & National Parks Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/lakes-rivers-holidays-catid.htm" title="Lakes & Rivers Tour Packages">Lakes & Rivers Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/wildlife-nature-holidays-catid.htm" title="Wildlife Tour Packages">Wildlife Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/food-drink-holidays-catid.htm" title="Food and Drink Tour Packages">Food and Drink Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/forts-palaces-holidays-catid.htm" title="Forts and Palaces Tour Packages">Forts and Palaces Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/snorkeling-holidays-catid.htm" title="Snorkeling Tour Packages">Snorkeling Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/parasailing-holidays-catid.htm" title="Parasailing Tour Packages">Parasailing Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/scuba-diving-holidays-catid.htm" title="Scuba Diving Tour Packages">Scuba Diving Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/water-skiing-holidays-catid.htm" title="Water Skiing Tour Packages">Water Skiing Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/water-scooters-holidays-catid.htm" title="Water Scooters Tour Packages">Water Scooters Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/paddle-boats-holidays-catid.htm" title="Paddle Boats Tour Packages">Paddle Boats Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/boat-safari-holidays-catid.htm" title="Boat Safari Tour Packages">Boat Safari Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/boat-cruise-holidays-catid.htm" title="Boat Cruise Tour Packages">Boat Cruise Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/beaches-sightseeing-holidays-catid.htm" title="Beaches Sightseeing Tour Packages">Beaches Sightseeing Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/speed-boats-holidays-catid.htm" title="Speed Boats Tour Packages">Speed Boats Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/motor-bike-holidays-catid.htm" title="Motor Biking Tour Packages">Motor Biking Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/heli-skiing-holidays-catid.htm" title="Heli Skiing Tour Packages">Heli Skiing Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/river-rafting-holidays-catid.htm" title="River Rafting Tour Packages">River Rafting Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/jungle-safari-holidays-catid.htm" title="Jungle Safari Tour Packages">Jungle Safari Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/monuments-historical-places-holidays-catid.htm" title="Monuments & Historical Places Tour Packages">Monuments & Historical Places Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/desert-holidays-catid.htm" title="Desert Safari Tour Packages">Desert Safari Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/diving-holidays-catid.htm" title="Diving Tour Packages">Diving Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/arab-baths-holidays-catid.htm" title="Arab Baths Tour Packages">Arab Baths Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/art-galleries-holidays-catid.htm" title="Art Galleries Tour Packages">Art Galleries Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/entertaining-live-shows-holidays-catid.htm" title="Entertaining Live Shows Tour Packages">Entertaining Live Shows Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/light-sound-shows-holidays-catid.htm" title="Light & Sound Shows Tour Packages">Light & Sound Shows Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/theme-parks-holidays-catid.htm" title="Theme Parks Tour Packages">Theme Parks Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/road-trip-holidays-catid.htm" title="Road Trip Tour Packages">Road Trip Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/skydiving-holidays-catid.htm" title="Skydiving Tour Packages">Skydiving Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/artificial-wall-climbing-holidays-catid.htm" title="Artificial Wall Climbing Tour Packages">Artificial Wall Climbing Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/river-cruising-holidays-catid.htm" title="River Cruising Tour Packages">River Cruising Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/bodyboarding-holidays-catid.htm" title="Bodyboarding Tour Packages">Bodyboarding Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/cable-car-tours-holidays-catid.htm" title="Cable Car Tour Packages">Cable Car Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/cave-diving-holidays-catid.htm" title="Cave Diving Tour Packages">Cave Diving Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/dolphin-watching-holidays-catid.htm" title="Dolphin Watching Tour Packages">Dolphin Watching Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/game-drives-holidays-catid.htm" title="Game Drives Tour Packages">Game Drives Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/shooting-ranges-holidays-catid.htm" title="Shooting Ranges Tour Packages">Shooting Ranges Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/swimming-holidays-catid.htm" title="Swimming Tour Packages">Swimming Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/bird-watching-holidays-catid.htm" title="Bird Watching Tour Packages">Bird Watching Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/caving-holidays-catid.htm" title="Caving Tour Packages">Caving Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/rock-climbing-holidays-catid.htm" title="Rock Climbing Tour Packages">Rock Climbing Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/paragliding-holidays-catid.htm" title="Paragliding Tour Packages">Paragliding Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/yak-safari-holidays-catid.htm" title="Yak Safari Tour Packages">Yak Safari Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/yoga-meditation-catid.htm" title="Yoga & Meditation Tour Packages">Yoga & Meditation Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/camel-safari-holidays-catid.htm" title="Camel Safari Tour Packages">Camel Safari Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/abseiling-holidays-catid.htm" title="Abseiling Tour Packages">Abseiling Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.rajtoursandtravels.co.in/dune-bashing-holidays-catid.htm" title="Dune Bashing Tour Packages">Dune Bashing Tours</a></span>
														<span class="uu db ar"><a class="showallspan" data-target="show" href="javascript:;" >View More</a></span>
													</div>
						</section>
												
						<div class="ac mb10px">
						<form class="inquiry-form" name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.rajtoursandtravels.co.in/enquiry-form-10028.htm">
						<input type="hidden" name="subject" value="Untouched Beauty of Kashmir Tour - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>							
						<input type="hidden" name="pkg_slno" value="28363"/>
						</form>
						<a href="javascript:;" class="submit-inquiry button p10px20px w150px fw6 large dib ttu ts0">Book Your Tour</a>
						</div>
											<div id="myModal" class="modal fade dn pf" role="dialog" style="z-index:9999;left:0;top:0%;width:100%;height:100%;background-color:rgba(0,0,0,0.6);overflow-x: hidden; overflow-y: auto;">
					    <!-- Modal content-->
					    <div style="max-width:380px;margin-top: 50px;min-height:400px;" class="modal-content data m0a p10px pr">
					      <div class="modal-header">
					        <a style="right:25px;top:25px;" class="pa b xxxlarge" data-dismiss="modal"><span class="xlarge">&times;</span></a>	        
					      </div>
					      <div class="modal-body">
					        <p>Loading...</p>
					      </div>
					      <div class="modal-footer">
					        
					      </div>
					    </div>
					</div>
					<script type="text/javascript">
						jQuery(document).ready(function(){
							jQuery(document).on("click", ".submit-inquiry" , function(e){e.stopPropagation()
								var form = jQuery(this).parent().find(".inquiry-form");
								if(form.length){
									jQuery.ajax({
										url: form.attr("action"),
										type: form.attr("method"),
										data:form.serialize(),
										crossDomain:true,
										success:function(res){
											jQuery("#myModal .modal-body").html(res);
										}
									});
								}
							});
							jQuery(document).on("click", "[data-dismiss=modal]", function(){
								jQuery("#myModal .modal-body").html("<p>Loading...</p>");
								jQuery("#myModal").hide();
							});
							jQuery(document).on("submit", "form[name=static_form]", function(e){				
								e.preventDefault();
								var isValidForm =static_inq_form_validate(jQuery(this).attr("form-id"));
								if(isValidForm == undefined){
									var form = jQuery(this);
									if(form.length){
										jQuery.ajax({
											url: form.attr("action"),
											type: form.attr("method"),
											data:form.serialize(),
											crossDomain:true,
											beforeSend:function(){
												jQuery("#myModal .modal-footer").html("");
											},
											success:function(res){
												jQuery("#myModal .modal-body").html(res);
												setTimeout(function(){
													jQuery("#myModal", document).hide();
													jQuery("#myModal .modal-body").html("<p>Loading...</p>");
													},2000)
											}
										});
									}
								}
							});
							var modal = jQuery("#myModal", document);
				
							jQuery(document).on("click", ".submit-inquiry" , function(){
							    modal.show();
							});
				
							window.onclick = function(event) {
							    if (jQuery(event.target) == modal) {
							        modal.css("display","none");
							    }
							}
						});
					</script>
									</div>
									<div class="col-3 thinColumn"><!--MIDDLE ROW1 COL-1 STARTS-->
					<div class="column_Box mc rghtFix">
					<div class="tcl bullet data divider enqForm stickyForm">
					<div class="h h2 ac xxlarge theme2 p10px" style="color:#fff;"><b class="plusMinus"></b>
					Fill Enquiry Form Below
					</div>
					<div class="showHide_rp mt7px p10px">
					<form name="package_form" method="post" action="//catalog.tourtravelworld.com/catalog-enquiry.php" onsubmit="return static_inq_form_validate(10029);">
					<div class="fo">
					<div class="mb15px">
					<input type="text" name="dynFrm_contact_person" id="dynFrm_contact_person_10029" placeholder="Your Full Name" />
					<span class="red small"></span>
					</div>
					<div class="fl w100 mb15px">
					<textarea name="dynFrm_details_2" id="dynFrm_details_2_10029">I am interested in Untouched Beauty of Kashmir Tour. Please get in contact with me.</textarea>
					<span class="fl red small"></span>
					</div>
					<div class="fl w100 mb15px df-dt">
					<div class="df-dtc w50 pr5px dateOpt pr"><input type="text" name="dynFrm_arrival_date" id="dynFrm_arrival_date_10029" class="dynFrm_arrival_date" style="padding-left:30px;" placeholder=" Departure Date" /><span class="fl red small"></span></div>
					<div class="df-dtc pl5px"><input type="text" name="dynFrm_duration" id="dynFrm_duration_10029" placeholder="Number of Days" /><span class="fl red small"></span></div>
					</div>  
					<div class="mb15px">
					<input type="text" name="dynFrm_email_id" id="dynFrm_email_id_10029" placeholder="Email" />
					<span class="red small"></span>
					</div> 
					<div class="mb20px fl w100">
					<div class="w60px pr fl ofh">
					<div id="isdpackCode" class="isdCode pr0px">+91</div>
					<select class="contSelect" name="dynFrm_country" id="dynFrm_country" onChange="document.getElementById('phone_package_isd').value=this.value.substr(3, 4); document.getElementById('isdpackCode').innerHTML=this.value.substr(3, 4);">
					
											
						<option value="AF^+93" >Afghanistan +93</option>
					
												
						<option value="CF^+236" >African Republic +236</option>
					
												
						<option value="AL^+355" >Albania +355</option>
					
												
						<option value="DZ^+213" >Algeria +213</option>
					
												
						<option value="AS^+0" >American Samoa +0</option>
					
												
						<option value="AD^+376" >Andorra +376</option>
					
												
						<option value="AO^+244" >Angola +244</option>
					
												
						<option value="AI^+264" >Anguilla +264</option>
					
												
						<option value="AG^+268" >Antigua and Barbuda +268</option>
					
												
						<option value="AR^+54" >Argentina +54</option>
					
												
						<option value="AM^+374" >Armenia +374</option>
					
												
						<option value="AW^+297" >Aruba +297</option>
					
												
						<option value="AU^+61" >Australia +61</option>
					
												
						<option value="AT^+43" >Austria +43</option>
					
												
						<option value="AZ^+994" >Azerbaijan +994</option>
					
												
						<option value="BS^+242" >Bahamas +242</option>
					
												
						<option value="BH^+973" >Bahrain +973</option>
					
												
						<option value="BD^+880" >Bangladesh +880</option>
					
												
						<option value="BB^+246" >Barbados +246</option>
					
												
						<option value="BY^+375" >Belarus +375</option>
					
												
						<option value="BE^+32" >Belgium +32</option>
					
												
						<option value="BZ^+501" >Belize +501</option>
					
												
						<option value="BJ^+229" >Benin +229</option>
					
												
						<option value="BM^+441" >Bermuda +441</option>
					
												
						<option value="BT^+975" >Bhutan +975</option>
					
												
						<option value="BO^+591" >Bolivia +591</option>
					
												
						<option value="BA^+387" >Bosnia and Herzegovina +387</option>
					
												
						<option value="BW^+267" >Botswana +267</option>
					
												
						<option value="BV^+47" >Bouvet +47</option>
					
												
						<option value="BR^+55" >Brazil +55</option>
					
												
						<option value="BN^+673" >Brunei +673</option>
					
												
						<option value="BG^+359" >Bulgaria +359</option>
					
												
						<option value="BF^+226" >Burkina +226</option>
					
												
						<option value="BF^+0" >Burkina Faso +0</option>
					
												
						<option value="BI^+257" >Burundi +257</option>
					
												
						<option value="KH^+855" >Cambodia +855</option>
					
												
						<option value="CM^+237" >Cameroon +237</option>
					
												
						<option value="CA^+1" >Canada +1</option>
					
												
						<option value="CV^+238" >Cape Verde +238</option>
					
												
						<option value="KY^+345" >Cayman Islands +345</option>
					
												
						<option value="236^+236" >Central African Republic +236</option>
					
												
						<option value="TD^+235" >Chad +235</option>
					
												
						<option value="IO^+246" >Chagos +246</option>
					
												
						<option value="CL^+56" >Chile +56</option>
					
												
						<option value="CN^+86" >China +86</option>
					
												
						<option value="CX^+61" >Christmas Island +61</option>
					
												
						<option value="CC^+61" >Cocos +61</option>
					
												
						<option value="CO^+57" >Colombia +57</option>
					
												
						<option value="KM^+269" >Comoros +269</option>
					
												
						<option value="CG^+242" >Congo +242</option>
					
												
						<option value="CK^+682" >Cook Islands +682</option>
					
												
						<option value="RCI^+506" >Costa Rica +506</option>
					
												
						<option value="HR^+385" >Croatia +385</option>
					
												
						<option value="CY^+357" >Cyprus +357</option>
					
												
						<option value="CZ^+420" >Czech Republic +420</option>
					
												
						<option value="DK^+45" >Denmark +45</option>
					
												
						<option value="DJ^+253" >Djibouti +253</option>
					
												
						<option value="DM^+767" >Dominica +767</option>
					
												
						<option value="DO^+809" >Dominican Republic +809</option>
					
												
						<option value="EOA^+257" >East Africa +257</option>
					
												
						<option value="TP^+670" >East Timor +670</option>
					
												
						<option value="EC^+593" >Ecuador +593</option>
					
												
						<option value="EG^+20" >Egypt +20</option>
					
												
						<option value="SV^+503" >El Salvador +503</option>
					
												
						<option value="GQ^+0" >Equatorial Guinea +0</option>
					
												
						<option value="ER^+291" >Eritrea +291</option>
					
												
						<option value="EE^+372" >Estonia +372</option>
					
												
						<option value="ET^+251" >Ethiopia +251</option>
					
												
						<option value="FO^+298" >Faroe +298</option>
					
												
						<option value="FM^+691" >Federated States of Micronesia +691</option>
					
												
						<option value="FJ^+679" >Fiji +679</option>
					
												
						<option value="FI^+358" >Finland +358</option>
					
												
						<option value="FR^+33" >France +33</option>
					
												
						<option value="FX^+590" >France, Metropolitan +590</option>
					
												
						<option value="GF^+594" >French Guiana +594</option>
					
												
						<option value="FP^+689" >French Polynesia +689</option>
					
												
						<option value="TF^+590" >French Southern Territories +590</option>
					
												
						<option value="GA^+241" >Gabon +241</option>
					
												
						<option value="GM^+220" >Gambia +220</option>
					
												
						<option value="GE^+995" >Georgia +995</option>
					
												
						<option value="DE^+49" >Germany +49</option>
					
												
						<option value="GH^+233" >Ghana +233</option>
					
												
						<option value="GI^+350" >Gibraltar +350</option>
					
												
						<option value="GR^+30" >Greece +30</option>
					
												
						<option value="GL^+299" >Greenland +299</option>
					
												
						<option value="GD^+809" >Grenada +809</option>
					
												
						<option value="Gre^+473" >Grenada +473</option>
					
												
						<option value="GP^+590" >Guadeloupe +590</option>
					
												
						<option value="GU^+1" >Guam +1</option>
					
												
						<option value="GT^+502" >Guatemala +502</option>
					
												
						<option value="GN^+224" >Guinea +224</option>
					
												
						<option value="GW^+245" >Guinea-bissau +245</option>
					
												
						<option value="GY^+592" >Guyana +592</option>
					
												
						<option value="HT^+509" >Haiti +509</option>
					
												
						<option value="HM^+61" >Heard and Mc Donald Islands +61</option>
					
												
						<option value="HN^+504" >Honduras +504</option>
					
												
						<option value="HU^+36" >Hungary +36</option>
					
												
						<option value="IS^+354" >Iceland +354</option>
					
												
						<option value="IN^+91"  selected="selected" >India +91</option>
					
												
						<option value="ID^+62" >Indonesia +62</option>
					
												
						<option value="IQ^+964" >Iraq +964</option>
					
												
						<option value="IE^+353" >Ireland +353</option>
					
												
						<option value="Isi^Isiolo" >Isiolo Isiolo</option>
					
												
						<option value="IL^+972" >Israel +972</option>
					
												
						<option value="IT^+39" >Italy +39</option>
					
												
						<option value="CI^+225" >Ivory Coast +225</option>
					
												
						<option value="JM^+876" >Jamaica +876</option>
					
												
						<option value="JP^+81" >Japan +81</option>
					
												
						<option value="JO^+962" >Jordan +962</option>
					
												
						<option value="KZ^+7" >Kazakhstan +7</option>
					
												
						<option value="KE^+254" >Kenya +254</option>
					
												
						<option value="KI^+686" >Kiribati +686</option>
					
												
						<option value="KW^+965" >Kuwait +965</option>
					
												
						<option value="KG^+996" >Kyrgyzstan +996</option>
					
												
						<option value="LA^+856" >Lao People's Democratic Republic +856</option>
					
												
						<option value="LA^+856" >Laos +856</option>
					
												
						<option value="LV^+371" >Latvia +371</option>
					
												
						<option value="LB^+961" >Lebanon +961</option>
					
												
						<option value="LS^+266" >Lesotho +266</option>
					
												
						<option value="LR^+231" >Liberia +231</option>
					
												
						<option value="LY^+218" >Libya +218</option>
					
												
						<option value="LI^+423" >Liechtenstein +423</option>
					
												
						<option value="LT^+370" >Lithuania +370</option>
					
												
						<option value="LU^+352" >Luxembourg +352</option>
					
												
						<option value="MO^+853" >Macau +853</option>
					
												
						<option value="MK^+389" >Macedonia +389</option>
					
												
						<option value="MG^+261" >Madagascar +261</option>
					
												
						<option value="MW^+265" >Malawi +265</option>
					
												
						<option value="MY^+60" >Malaysia +60</option>
					
												
						<option value="MV^+960" >Maldives +960</option>
					
												
						<option value="ML^+223" >Mali +223</option>
					
												
						<option value="MT^+356" >Malta +356</option>
					
												
						<option value="FK^+500" >Malvinas +500</option>
					
												
						<option value="MH^+692" >Marshall Islands +692</option>
					
												
						<option value="MQ^+596" >Martinique +596</option>
					
												
						<option value="MR^+222" >Mauritania +222</option>
					
												
						<option value="MU^+230" >Mauritius +230</option>
					
												
						<option value="YT^+269" >Mayotte +269</option>
					
												
						<option value="MX^+52" >Mexico +52</option>
					
												
						<option value="MD^+0" >Moldova +0</option>
					
												
						<option value="MD^+373" >Moldova (Republic of Moldova) +373</option>
					
												
						<option value="MC^+377" >Monaco +377</option>
					
												
						<option value="MN^+976" >Mongolia +976</option>
					
												
						<option value="ME^+381" >Montenegro +381</option>
					
												
						<option value="MS^+664" >Montserrat +664</option>
					
												
						<option value="MA^+212" >Morocco +212</option>
					
												
						<option value="MZ^+258" >Mozambique +258</option>
					
												
						<option value="MM^+95" >Myanmar +95</option>
					
												
						<option value="NA^+264" >Namibia +264</option>
					
												
						<option value="NR^+674" >Nauru +674</option>
					
												
						<option value="NP^+977" >Nepal +977</option>
					
												
						<option value="NL^+31" >Netherlands +31</option>
					
												
						<option value="AN^+599" >Netherlands Antilles +599</option>
					
												
						<option value="NC^+687" >New Caledonia +687</option>
					
												
						<option value="PG^+675" >New Guinea +675</option>
					
												
						<option value="NZ^+64" >New Zealand +64</option>
					
												
						<option value="NI^+505" >Nicaragua +505</option>
					
												
						<option value="NE^+227" >Niger +227</option>
					
												
						<option value="NG^+234" >Nigeria +234</option>
					
												
						<option value="NU^+683" >Niue +683</option>
					
												
						<option value="NF^+672" >Norfolk Island +672</option>
					
												
						<option value="MP^+670" >Northern Mariana Islands +670</option>
					
												
						<option value="NO^+47" >Norway +47</option>
					
												
						<option value="OM^+968" >Oman +968</option>
					
												
						<option value="PK^+92" >Pakistan +92</option>
					
												
						<option value="PW^+680" >Palau +680</option>
					
												
						<option value="PA^+507" >Panama +507</option>
					
												
						<option value="PG^+0" >Papua New Guinea +0</option>
					
												
						<option value="PY^+595" >Paraguay +595</option>
					
												
						<option value="PE^+51" >Peru +51</option>
					
												
						<option value="PH^+63" >Philippines +63</option>
					
												
						<option value="PN^+872" >Pitcairn +872</option>
					
												
						<option value="PL^+48" >Poland +48</option>
					
												
						<option value="PF^+689" >Polynesia +689</option>
					
												
						<option value="PT^+351" >Portugal +351</option>
					
												
						<option value="PR^+1-787" >Puerto Rico +1-787</option>
					
												
						<option value="QA^+974" >Qatar +974</option>
					
												
						<option value="RE^+262" >Reunion +262</option>
					
												
						<option value="RO^+40" >Romania +40</option>
					
												
						<option value="RU^+7" >Russia +7</option>
					
												
						<option value="RW^+250" >Rwanda +250</option>
					
												
						<option value="KN^+869" >Saint Kitts and Nevis +869</option>
					
												
						<option value="LC^+758" >Saint Lucia +758</option>
					
												
						<option value="VC^+784" >Saint Vincent and the Grenadines +784</option>
					
												
						<option value="WS^+685" >Samoa +685</option>
					
												
						<option value="SM^+378" >San Marino +378</option>
					
												
						<option value="ST^+239" >Sao Tome And Principe +239</option>
					
												
						<option value="SA^+966" >Saudi Arabia +966</option>
					
												
						<option value="SN^+221" >Senegal +221</option>
					
												
						<option value="RS^+381" >Serbia +381</option>
					
												
						<option value="SC^+248" >Seychelles +248</option>
					
												
						<option value="SL^+232" >Sierra Leone +232</option>
					
												
						<option value="SG^+65" >Singapore +65</option>
					
												
						<option value="SK^+421" >Slovakia +421</option>
					
												
						<option value="SI^+386" >Slovenia +386</option>
					
												
						<option value="SB^+677" >Solomon Islands +677</option>
					
												
						<option value="SO^+252" >Somalia +252</option>
					
												
						<option value="ZA^+27" >South Africa +27</option>
					
												
						<option value="GS^+44" >South Georgia and the South Sandwich Islands +44</option>
					
												
						<option value="KR^+82" >South Korea +82</option>
					
												
						<option value="ES^+34" >Spain +34</option>
					
												
						<option value="LK^+94" >Sri Lanka +94</option>
					
												
						<option value="SH^+290" >St. Helena +290</option>
					
												
						<option value="PM^+508" >St. Pierre and Miquelon +508</option>
					
												
						<option value="SD^+249" >Sudan +249</option>
					
												
						<option value="SR^+597" >Suriname +597</option>
					
												
						<option value="SJ^+47" >Svalbard and Jan Mayen Islands +47</option>
					
												
						<option value="SZ^+268" >Swaziland +268</option>
					
												
						<option value="SE^+46" >Sweden +46</option>
					
												
						<option value="CH^+41" >Switzerland +41</option>
					
												
						<option value="TW^+886" >Taiwan +886</option>
					
												
						<option value="TJ^+7" >Tajikistan +7</option>
					
												
						<option value="TZ^+255" >Tanzania +255</option>
					
												
						<option value="TH^+66" >Thailand +66</option>
					
												
						<option value="TG^+228" >Togo +228</option>
					
												
						<option value="TK^+64" >Tokelau +64</option>
					
												
						<option value="TO^+676" >Tonga +676</option>
					
												
						<option value="TT^+868" >Trinidad and Tobago +868</option>
					
												
						<option value="TN^+216" >Tunisia +216</option>
					
												
						<option value="TR^+90" >Turkey +90</option>
					
												
						<option value="TM^+993" >Turkmenistan +993</option>
					
												
						<option value="TC^+649" >Turks and Caicos Islands +649</option>
					
												
						<option value="TV^+688" >Tuvalu +688</option>
					
												
						<option value="AE^+971" >UAE +971</option>
					
												
						<option value="UG^+256" >Uganda +256</option>
					
												
						<option value="UA^+380" >Ukraine +380</option>
					
												
						<option value="UK^+44" >United Kingdom +44</option>
					
												
						<option value="UM^+1" >United States Minor Outlying Islands +1</option>
					
												
						<option value="UY^+598" >Uruguay +598</option>
					
												
						<option value="US^+1" >USA +1</option>
					
												
						<option value="UZ^+998" >Uzbekistan +998</option>
					
												
						<option value="VU^+678" >Vanuatu +678</option>
					
												
						<option value="VA^+0" >Vatican City +0</option>
					
												
						<option value="VA^+39" >Vatican City State (Holy See) +39</option>
					
												
						<option value="VE^+58" >Venezuela +58</option>
					
												
						<option value="VN^+84" >Vietnam +84</option>
					
												
						<option value="VG^+1" >Virgin Islands (British) +1</option>
					
												
						<option value="VI^+1" >Virgin Islands (U.S.) +1</option>
					
												
						<option value="WF^+681" >Wallis and Futuna Islands +681</option>
					
												
						<option value="EH^+212" >Western Sahara +212</option>
					
												
						<option value="YE^+967" >Yemen +967</option>
					
												
						<option value="YU^+381" >Yugoslavia +381</option>
					
												
						<option value="ZR^+243" >Zaire +243</option>
					
												
						<option value="ZM^+260" >Zambia +260</option>
					
												
						<option value="ZW^+263" >Zimbabwe +263</option>
					
											</select>
					</div>									
					<input type="text" name="dynFrm_phone" id="dynFrm_phone_10029" class="fl" style="width:calc(100% - 62px);" placeholder="Mobile No" />
					<span class="fl red small"></span>
					</div>					
										
					<div class="mb5px ac">
					<input type="submit" name="submit" value="Send Enquiry" class="dib theme1 p12px bdr fw6">
					<input type="hidden" name="phone_isd" id="phone_package_isd" value="+91">
					<input type="hidden" name="subject" value="Untouched Beauty of Kashmir Tour - Tour Package"/>
					<input type="hidden" name="allocate_type" value="tour"/>
					<input type="hidden" name="pkg_slno" value="28363"/>
					<input type="hidden" name="current_url" value="https://www.rajtoursandtravels.co.in/tour-packages/untouched-beautyof-kashmir-tour1.htm">
				  	<input type="hidden" name="web_address" value="https://www.rajtoursandtravels.co.in">
				  	<input type="hidden" name="inq_thanks_msg" value="Thank you for inquiry.<br /><br />We have received your request. Our Sales Team will soon get in touch with you.<br /><br /><br />">
					<input type="hidden" name="inq_thanks_title" value="Enquiry">
				  	<input type="hidden" name="redirected_url" value="https://www.rajtoursandtravels.co.in/thanks.htm">
					<input type="hidden" name="catalog_mi" value="27631">
				  	<input type="hidden" name="id" value="static_form">
				  	<input type="hidden" name="form_id" value="10029">
					</form>
					</div>
					</div>					
					</div>
					</div>
					<style>
					.ui-datepicker-trigger {
						vertical-align : middle;
					}
					</style>
					<script>
					jQuery('.dynFrm_arrival_date').datepicker({minDate: 0,
					buttonImage: '//catalog.wlimg.com/jquery-date-picker/calbtn.gif',
					buttonText: 'Click to view calendar',
				    buttonImageOnly: true,
				    showOn: 'button',
				    changeMonth: true,
				    changeYear: true,
				    onClose: function(dateText, inst) {
				        var endDateTextBox = jQuery('.dynFrm_departure_date');
				        if (endDateTextBox.val() != '') {
				            var testStartDate = new Date(dateText);
				            var testEndDate = new Date(endDateTextBox.val());
				            if (testStartDate > testEndDate)
				                endDateTextBox.val(dateText);
				        }
				    }, 
					    onSelect: function (selectedDateTime){
					        var start = jQuery(this).datepicker('getDate');
					        jQuery('.dynFrm_departure_date').datepicker('option', 'minDate', new Date(start.getTime()));
					        jQuery('#dynFrm_departure_date').datepicker('option', 'minDate', new Date(start.getTime()));
					    }    
					});
					jQuery('.dynFrm_departure_date').datepicker({
					minDate: 0,
					buttonImage: '//catalog.wlimg.com/jquery-date-picker/calbtn.gif',
					buttonText: 'Click to view calendar',
				    buttonImageOnly: true,
				    showOn: 'button',
				    changeMonth: true,
				    changeYear: true,
				    onClose: function(dateText, inst) {
				        var startDateTextBox = jQuery('.dynFrm_arrival_date');
				        if (startDateTextBox.val() != '') {
				            var testStartDate = new Date(startDateTextBox.val());
				            var testEndDate = new Date(dateText);
				            if (testStartDate > testEndDate)
				                startDateTextBox.val(dateText);
				        }
				    },
				    onSelect: function (selectedDateTime){
				        var end = jQuery(this).datepicker('getDate');
				        jQuery('.dynFrm_arrival_date').datepicker('option', 'maxDate', new Date(end.getTime()) );
				        jQuery('#dynFrm_arrival_date').datepicker('option', 'maxDate', new Date(end.getTime()) );
				    }
					});
					</script>
					<script>
					jQuery(document).ready(function(){
					var sticky = jQuery('.stickyForm').offset().top;
					jQuery(window).scroll(function(){      
					 if(jQuery(window).scrollTop() > sticky){
					  jQuery('.stickyForm').css('position','fixed');
					  jQuery('.stickyForm').css('top','75px'); 
					 }
					 else if (jQuery(window).scrollTop() <= sticky) {
					  jQuery('.stickyForm').css('position','');
					  jQuery('.stickyForm').css('top','');
					 }  
					if (jQuery('.stickyForm').offset().top + jQuery(".stickyForm").height() > jQuery(".rel-prop").offset().top) {
					  jQuery('.stickyForm').css('top',-(jQuery(".stickyForm").offset().top + jQuery(".stickyForm").height() - jQuery(".rel-prop").offset().top));
					}
					});
					});
					</script>
					<script>
					jQuery(document).ready(function(e){
					if (jQuery(window).width() < 992) {
					jQuery(".rghtFix .enqForm .h").on("click", function(){
					  jQuery(this).find('.plusMinus').toggleClass('act').parent().next('.showHide_rp').slideToggle('slow');
					});  
					jQuery(".rghtFix .enqForm .plusMinus").on("click", function(e){
					e.stopPropagation(); 
					});
					}
					});  
					</script>
					</div>
					</div>
									
				
				</div>
				
										<section class="pt30px pb10px relTour-pkg rel-prop">
						<div class="wrap">      
						<div class="fo">
						<div class="ac mb7px"><div><h2 class="hd_NT">Similar Tour Packages for Jammu, Katra, Srinagar, Kashmir, Pahalgam, Sonamarg, Gulmarg</h2></div></div>
						<div class="ic" id="1102_3-1">
						<div class="slider">
						<ul class="bxslider987">
											
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.rajtoursandtravels.co.in/tour-packages/kashmir-paradiseon-earth1.htm'">
															<div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px"><img src="https://ttw.wlimg.com/package-images/photo-small/wh1/dir_1/27631/371548.jpg"  height=""  width=""    alt="Kashmir: Paradise On Earth." title="Kashmir: Paradise On Earth."  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.rajtoursandtravels.co.in/tour-packages/kashmir-paradiseon-earth1.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								6 Nights / 7 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.rajtoursandtravels.co.in/tour-packages/kashmir-paradiseon-earth1.htm" title="Kashmir: Paradise On Earth."><h3>Kashmir: Paradise On Earth.</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.rajtoursandtravels.co.in/tour-packages/glorious-kashmir-with-vaishnodevi.htm'">
															<div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px"><img src="https://ttw.wlimg.com/package-images/photo-small/wh1/dir_1/27631/351926.jpg"  height=""  width=""    alt="Glorious Kashmir with Vaishnodevi" title="Glorious Kashmir with Vaishnodevi"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.rajtoursandtravels.co.in/tour-packages/glorious-kashmir-with-vaishnodevi.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								7 Nights / 8 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.rajtoursandtravels.co.in/tour-packages/glorious-kashmir-with-vaishnodevi.htm" title="Glorious Kashmir with Vaishnodevi"><h3>Glorious Kashmir With Vaishnodevi</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.rajtoursandtravels.co.in/tour-packages/kashmir-paradiseon-earth-tour1.htm'">
															<div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px"><img src="https://ttw.wlimg.com/package-images/photo-small/wh1/dir_1/27631/56004.jpg"  height=""  width=""    alt="Srinagar" title="Srinagar"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.rajtoursandtravels.co.in/tour-packages/kashmir-paradiseon-earth-tour1.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								6 Nights / 7 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.rajtoursandtravels.co.in/tour-packages/kashmir-paradiseon-earth-tour1.htm" title="Kashmir:Paradise on Earth Tour"><h3>Kashmir:paradise On Earth Tour</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.rajtoursandtravels.co.in/tour-packages/the-heaven-called-ladakh-tour1.htm'">
															<div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px"><img src="https://ttw.wlimg.com/package-images/photo-small/wh1/dir_1/27631/48595.jpg"  height=""  width=""    alt="The Heaven Called Ladakh Tour" title="The Heaven Called Ladakh Tour"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.rajtoursandtravels.co.in/tour-packages/the-heaven-called-ladakh-tour1.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								14 Nights / 15 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.rajtoursandtravels.co.in/tour-packages/the-heaven-called-ladakh-tour1.htm" title="The Heaven Called Ladakh Tour"><h3>The Heaven Called Ladakh Tour</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.rajtoursandtravels.co.in/tour-packages/glimpsesof-kashmir-tour1.htm'">
															<div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px"><img src="https://ttw.wlimg.com/package-images/photo-small/wh1/dir_1/27631/55897.jpg"  height=""  width=""    alt="Srinagar" title="Srinagar"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.rajtoursandtravels.co.in/tour-packages/glimpsesof-kashmir-tour1.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								5 Nights / 6 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.rajtoursandtravels.co.in/tour-packages/glimpsesof-kashmir-tour1.htm" title="Glimpses of  Kashmir Tour"><h3>Glimpses Of  Kashmir Tour</h3></a></div>
							</div>
							</div>						
							</li>
															
						</ul>
						</div>
						</div> 
													<style>
							.relTour-pkg .slider ul li{max-width:214px;margin-bottom:20px;padding-left:5px;padding-right:6px;box-sizing:border-box;margin-right:12px;}
							</style>	
														  
						 </div>
					     </div>
					    </section>
											<section class="pt20px pb20px absTour-Title rel-prop">
					<div class="wrap">
					<div class="fo">     	
					<div class="ac mb7px"><div><h2 class="hd_NT">Explore Tour Packages by Destination</h2></div></div>     	
					<div class="ic" id="1102_3-1">
					<div class="slider">
					<ul class="bxslider988">								
					
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.rajtoursandtravels.co.in/packages-in-srinagar.htm" title="Packages in Srinagar" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10078-classified.jpg"  height=""  width=""    alt="Srinagar" title="Srinagar" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.rajtoursandtravels.co.in/packages-in-srinagar.htm" title="Packages in Srinagar">Srinagar Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.rajtoursandtravels.co.in/packages-in-pahalgam.htm" title="Packages in Pahalgam" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10631-classified.jpg"  height=""  width=""    alt="Pahalgam" title="Pahalgam" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.rajtoursandtravels.co.in/packages-in-pahalgam.htm" title="Packages in Pahalgam">Pahalgam Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.rajtoursandtravels.co.in/packages-in-gulmarg.htm" title="Packages in Gulmarg" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/11225-classified.jpg"  height=""  width=""    alt="Gulmarg" title="Gulmarg" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.rajtoursandtravels.co.in/packages-in-gulmarg.htm" title="Packages in Gulmarg">Gulmarg Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.rajtoursandtravels.co.in/packages-in-sonamarg.htm" title="Packages in Sonamarg" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10633-classified.jpg"  height=""  width=""    alt="Sonamarg" title="Sonamarg" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.rajtoursandtravels.co.in/packages-in-sonamarg.htm" title="Packages in Sonamarg">Sonamarg Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.rajtoursandtravels.co.in/packages-in-port-blair.htm" title="Packages in Port Blair" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10155-classified.jpg"  height=""  width=""    alt="Port Blair" title="Port Blair" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.rajtoursandtravels.co.in/packages-in-port-blair.htm" title="Packages in Port Blair">Port Blair Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.rajtoursandtravels.co.in/packages-in-havelock.htm" title="Packages in Havelock" >
						<img src="https://ttw.wlimg.com/package-images/photo-small/wh1/dir_1/27631/351418.jpg"  height=""  width=""    alt="Packages in Havelock" title="Packages in Havelock" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.rajtoursandtravels.co.in/packages-in-havelock.htm" title="Packages in Havelock">Havelock Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.rajtoursandtravels.co.in/packages-in-thimphu.htm" title="Packages in Thimphu" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/11284-classified.jpg"  height=""  width=""    alt="Thimphu" title="Thimphu" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.rajtoursandtravels.co.in/packages-in-thimphu.htm" title="Packages in Thimphu">Thimphu Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.rajtoursandtravels.co.in/packages-in-phuentsholing.htm" title="Packages in Phuentsholing" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/11957-classified.jpg"  height=""  width=""    alt="Phuentsholing" title="Phuentsholing" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.rajtoursandtravels.co.in/packages-in-phuentsholing.htm" title="Packages in Phuentsholing">Phuentsholing Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.rajtoursandtravels.co.in/packages-in-leh-ladakh.htm" title="Packages in Leh Ladakh" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/11219-classified.jpg"  height=""  width=""    alt="Leh Ladakh" title="Leh Ladakh" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.rajtoursandtravels.co.in/packages-in-leh-ladakh.htm" title="Packages in Leh Ladakh">Leh Ladakh Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.rajtoursandtravels.co.in/packages-in-bangkok.htm" title="Packages in Bangkok" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/11277-classified.jpg"  height=""  width=""    alt="Bangkok" title="Bangkok" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.rajtoursandtravels.co.in/packages-in-bangkok.htm" title="Packages in Bangkok">Bangkok Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.rajtoursandtravels.co.in/packages-in-jammu.htm" title="Packages in Jammu" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10074-classified.jpg"  height=""  width=""    alt="Jammu" title="Jammu" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.rajtoursandtravels.co.in/packages-in-jammu.htm" title="Packages in Jammu">Jammu Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.rajtoursandtravels.co.in/packages-in-kovalam.htm" title="Packages in Kovalam" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10218-classified.jpg"  height=""  width=""    alt="Kovalam" title="Kovalam" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.rajtoursandtravels.co.in/packages-in-kovalam.htm" title="Packages in Kovalam">Kovalam Tours</a></div>
						</div> 
						</li>
											</ul>
					</div>
					</div>
					 
							<script>
							$(document).ready(function(){			
							$('.bxslider988').bxSlider({
							mode:'horizontal',				
							slideWidth: 214,maxSlides: 10,slideMargin:12,auto: true, 
							autoDirection:'next',
							moveSlides: 1,
							pause:2000,
							pager:false,
							pagerType:'full',
							autoControls: false, 
							controls:true, 
							autoHover:true,				
							speed:1000
							});
							});
							</script>
												
					</div>
					</div>
					</section>
									
				</div>
				</section>
				
				<script>
					window.addEventListener("DOMContentLoaded", function(){
						jQuery(document).on("click", ".showallspan", function(){
							if(jQuery(this).attr("data-target") === 'show'){
								jQuery(this).text("View Less");
								jQuery(this).attr("data-target", "hide");
								jQuery(this).closest("div").find(".spanlist").removeClass("dn");
							}else{
								jQuery(this).text("View More");
								jQuery(this).attr("data-target", "show");
								jQuery(this).closest("div").find(".spanlist").addClass("dn");
							}
						});
					});
				</script>
				";i:1;s:71:"Book Untouched Beauty of Kashmir Tour - 7 Nights / 8 Days Tour Packages";i:2;s:218:"book untouched beauty of kashmir tour - 7 nights / 8 days tour packages, religious & pilgrimage tour packages, jammu, srinagar, kashmir, katra, gulmarg, sonamarg, pahalgam, shankaracharya temple, dal lake tour packages";i:3;s:271:"Book Untouched Beauty of Kashmir Tour - 7 Nights / 8 Days tour packages from Raj Tours And Travels - Get attractive 7 Nights / 8 Days Religious & Pilgrimage  tour packages for  Jammu, Srinagar, Kashmir, Katra, Gulmarg, Sonamarg, Pahalgam, Shankaracharya Temple, Dal Lake.";i:4;s:1216:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Jammu, Srinagar, Kashmir, Katra, Gulmarg, Sonamarg, Pahalgam, Shankaracharya Temple, Dal Lake"        
		                 },
		      "description": "Any Air or Train fare and Helicopter charges. 
Gondola ride, Pony ride, Boating, horse riding, etc.
Chandanwadi, Aru valley and Betaab Valley sightseeing at Pahalgam. 
Travel insurance, Medical expenses and Rescue evacuation due to mishaps.  
Personal expenses such as laundry, telephone call, tips, porterages, any camera fees etc.
Expenses caused by factors beyond our control like rail and flight delays, roadblocks, vehicle malfunctions, political disturbances etc.
Any increase in fuel surcharge or any kind of taxes levied by the respective government or statutory bodies, the tour price will be amended in accordance..
Anything which is not mentioned “ Cost Includes” 
3.09 % Government service tax. ",
		      "name": "Untouched Beauty of Kashmir Tour",
		      "telephone": "+91-9823807778"
		    }
		    </script>
			";i:5;N;i:6;s:74:"https://ttw.wlimg.com/package-images/photo-small/wh1/dir_1/27631/56010.jpg";}