a:6:{i:0;s:97823:"					<div id="append2PageTittle">
    				<div class="page-title-inner bread-right head-inner fo">
    				<div id="breadcrumb">
					<div class="h1"><h1>Shimla Manali Tour Package By Cab</h1></div>
					<p class="breadcrumb ar uu small"><a href="http://www.jmgroupofservices.com/" title="Home">Home</a>
					
											<b class="ffv p2px">&rsaquo;</b><a href="http://www.jmgroupofservices.com/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
																
					<b class="ffv p2px">&rsaquo;</b> Shimla Manali Tour Package By Cab</p>
					</div>
					</div>
					</div>
					<script>jQuery('#breadcrumbA').append(jQuery('#append2PageTittle').html());jQuery('#append2PageTittle').remove()</script>
									<section id="middle" class="propDtls">
				<div class="wrap thinFormat " id="bodyFormatNT">
								
				<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/dir_28/829818/319720.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_28/829818/319720.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319720.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></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/dir_28/829818/319615.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_28/829818/319615.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319615.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></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/dir_28/829818/319719.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_28/829818/319719.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319719.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></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/dir_28/829818/319721.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_28/829818/319721.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319721.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></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/dir_28/829818/319722.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_28/829818/319722.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319722.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></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/dir_28/829818/319723.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_28/829818/319723.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319723.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></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/dir_28/829818/319724.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_28/829818/319724.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319724.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></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/dir_28/829818/319725.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_28/829818/319725.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319725.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></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/dir_28/829818/319720.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></a></li>
																<li data-slideIndex="1"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319615.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></a></li>
																<li data-slideIndex="2"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319719.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></a></li>
																<li data-slideIndex="3"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319721.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></a></li>
																<li data-slideIndex="4"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319722.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></a></li>
																<li data-slideIndex="5"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319723.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></a></li>
																<li data-slideIndex="6"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319724.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></a></li>
																<li data-slideIndex="7"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319725.jpg"  height="150"  width="150"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" /></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">
					<h1>Shimla Manali Tour Package By Cab</h1>											<p class="mb5px"><b>Duration :</b> 
						5 Nights / 6 Days 
						</p>
												<p class="mb5px"><b>Destination Covered :</b> New Delhi, Manali, Shimla</p>
												<p class="mb5px"><b>Tour Themes :</b> Hill Stations & Valleys</p>
												<div class="fo mt20px mb20px ac xxlarge">
          				<p class="xxlarge b dif mb2px">
						<i class="fa fa-inr"></i> 16249						</p>
						<p class="xxsmall alpha50">Per Person</p>
          				</div>
											<div class="ac">
					<form class="inquiry-form" name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.jmgroupofservices.com/enquiry-form-10028.htm">
					<input type="hidden" name="subject" value="Shimla Manali Tour Package By Cab - Tour Package"/>
					<input type="hidden" name="allocate_type" value="tour"/>							
					<input type="hidden" name="pkg_slno" value="198929"/>
					</form>
					<a href="javascript:void(0);" 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>
														<div class="data mb15px p15px">           
								<div class="fw7 xxlarge mb10px mt5px"><h2>New Delhi, Manali and Shimla Tour Overview</h2></div>
								<p class="">					
								Travel Date                                               Season Rate <br />
        No of Pax                                                   2 Adults <br />
        Pick up Point                                              Delhi<br />
        Drop Point                                                  Delhi<br />
        Destination                                                Shimla-Kullu–Manali<br />
        Vehicle offered                                          Swift Dzire/ Toyota Etios <br />
        Rooms                                                        1 Room								</p>
								</div>
																<div class="mt20px mb10px">
		  						<div class="b xlarge"><h2>New Delhi, Manali and Shimla Tour Itinerary</h2></div>
					            </div>
					            
										<div class="product-desc data bdr0 mb12px">  
		   								<div class="sub-title p15px"><a href="javascript:void(0)" class="clickable db"><b class="dif mr2px">Day 1:</b> <h3>DELHI TO SHIMLA</h3>
										<span class="fr pr10px"><i class="fa fa-angle-up"></i></span></a>
										</div>
										<div class="fo db product-detail p15px pt0px ">
											<div class="frwm lh0 pr">
			 								<span class="itnry-zoom dib">
													<a  data-fancybox="showZoomImage1" href="https://ttw.wlimg.com/package-images/photo-big/dir_28/829818/319721.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319721.jpg"  height="200"  width="200"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;"  /></a>
											</span> 
											</div>Meal: - Breakfast & Dinner<br />
Stay Shimla<br />
On arrival at Delhi Airport/Railway Station meets our representative and drive to Shimla. Shimla was the former summer capital of British India. Set amidst the snow Shivalik Mountain which offers some of the most stunning views of the mighty Himalayas. On arrival at Shimla Check in the hotel Dinner and overnight stay at Hotel in shimla.
										</div>  
			 							</div>
										<div class="product-desc data bdr0 mb12px">  
		   								<div class="sub-title p15px"><a href="javascript:void(0)" class="clickable db"><b class="dif mr2px">Day 2:</b> <h3>SHIMLA LOCAL CITY SIGHTSEEING</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="fo db product-detail p15px pt0px dn">
											<div class="frwm lh0 pr">
			 								<span class="itnry-zoom dib">
													<a  data-fancybox="showZoomImage2" href="https://ttw.wlimg.com/package-images/photo-big/dir_28/829818/319722.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319722.jpg"  height="200"  width="200"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;"  /></a>
											</span> 
											</div>Meal: - Breakfast & Dinner<br />
Stay: - Shimla <br />
Today Morning after breakfast proceed to visit local sight seen of Shimla & Kufri , India’s one of the best holiday paradise Kufri in shimla is beautifully tucked on an altitude of 2,622 meter. The place is a tourist hotspot for its awesome scenic and sports activities. Evening time to stroll in the famous shopping place of Shimla- “The Mall & the Ridge” This large one space in the heart of town present excellent views of the mountain ranges. After sight seen drive back to hotel Dinner and overnight stay at hotel in Shimla.
										</div>  
			 							</div>
										<div class="product-desc data bdr0 mb12px">  
		   								<div class="sub-title p15px"><a href="javascript:void(0)" class="clickable db"><b class="dif mr2px">Day 3:</b> <h3>SHIMLA TO MANALI (ON THE WAY KULLU VALLEY SIGHTSEEING)</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="fo db product-detail p15px pt0px dn">
											<div class="frwm lh0 pr">
			 								<span class="itnry-zoom dib">
													<a  data-fancybox="showZoomImage3" href="https://ttw.wlimg.com/package-images/photo-big/dir_28/829818/319723.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319723.jpg"  height="200"  width="200"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;"  /></a>
											</span> 
											</div>Meal: - Breakfast & Dinner<br />
Stay_ Manali <br />
  Today morning after breakfast Check out from the Hotel drive to Manali on the way visit sight-seeing like  Sundernagar  lake, Pandoh dam, Mini Vaishno Devi Temple  Kullu etc. after sight seen proceed to Manali check in the hotel Dinner & over night stay at hotel in Manali.
										</div>  
			 							</div>
										<div class="product-desc data bdr0 mb12px">  
		   								<div class="sub-title p15px"><a href="javascript:void(0)" class="clickable db"><b class="dif mr2px">Day 4:</b> <h3>MANALI LOCAL CITY SIGHTSEEING</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="fo db product-detail p15px pt0px dn">
											<div class="frwm lh0 pr">
			 								<span class="itnry-zoom dib">
													<a  data-fancybox="showZoomImage4" href="https://ttw.wlimg.com/package-images/photo-big/dir_28/829818/319724.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319724.jpg"  height="200"  width="200"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;"  /></a>
											</span> 
											</div>Meal: - Breakfast & Dinner<br />
Stay_ Manali<br />
Today morning arrive at Manali Check in the Hotel and after fresup drive to Manali and visit local sightseeing of Manali “HADIMBA TEMPLE” Built in 1553 with a superbly crafted four tiered pagoda roof, it is famous for its exquisitely carved doorway. ”CLUB HOUSE”  The club House with its comprehensive facilities that include a roller skating rink an auditorium, billiards rooms, a library   a bar and restraint makes wonderful outing <br />
                                                                                                                                                <br />
for the day. “Tibetan Monastery, Van Vihar, and “VASHIST’ well known for its hot springs. There are old temples dedicated to the sage Vashisht and to lord Rama. After sightseeing drive back to hotel Dinner and overnight stay at hotel.
										</div>  
			 							</div>
										<div class="product-desc data bdr0 mb12px">  
		   								<div class="sub-title p15px"><a href="javascript:void(0)" class="clickable db"><b class="dif mr2px">Day 5:</b> <h3>MANALI SOLANG VALLEY SIGHTSEEING</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="fo db product-detail p15px pt0px dn">
											<div class="frwm lh0 pr">
			 								<span class="itnry-zoom dib">
													<a  data-fancybox="showZoomImage5" href="https://ttw.wlimg.com/package-images/photo-big/dir_28/829818/319725.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/319725.jpg"  height="200"  width="200"    alt="Shimla Manali Tour Package By Cab" title="Shimla Manali Tour Package By Cab" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;"  /></a>
											</span> 
											</div>Meal: - Breakfast & Dinner<br />
Stay_ Manali<br />
Today morning after breakfast visit Solang Valley.  Dinner and overnight stay at hotel.<br />
<br />
                                                                                                                                 <br />
<br />
ABOUT SOLANG VALLEY                                                                                <br />
                                                                                                                                                    <br />
                                                                                                                                                                                                                                                                                       Solang valley in Manali is located at a distance on 13 kms in a side valley at the top of the Kullu valley is a splendid valley between Solang village and Beas kund. Solang Valley offers the view of glaciers and snow capped mountains and peaks. Solang Valley has fine ski slopes. The Mountaineering Institute for Manali has installed a ski lift for training purpose.  Located here is a hut and guest house of the Mountaineering and Allied sports institute Manali.  The winter skiing festival is organized in Solang valley. Sklng and paragliding are two main activities are organized here. Apart from this many other adventure sports are available like Zoorbing, Horse riding & Motor Bikes tiding etc.<br />
 <br />
Please Note:-Since the National Green Tribunal is allowing only limited vehicle to Rohtang pass per day. Rohtang pass will in subject to availability of permit from the SDM office Manali on the spot with additional cost.
										</div>  
			 							</div>
										<div class="product-desc data bdr0 mb12px">  
		   								<div class="sub-title p15px"><a href="javascript:void(0)" class="clickable db"><b class="dif mr2px">Day 6:</b> <h3>MANALI TO DELHI</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="fo db product-detail p15px pt0px dn">Meal: - Breakfast <br />
Today morning after breakfast check out from the hotel drive to Delhi .on the visit Kullu Valley Mandi Sundernagar Lake and we will drop you at Delhi Airport.<br />
 Tour ends but the sweet memories remain
										</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(".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(".sub-title").removeClass('on');
										    jQuery('.product-detail').slideUp();
								          	$this.addClass('on');
										    $this.next().slideDown(); 
								          }		  
								          if($this.find('i').hasClass('fa-angle-up')){
								          	$this.find('i').removeClass('fa-angle-up').addClass('fa-angle-down');
								          } else {
								          	$this.find('i').removeClass('fa-angle-down').addClass('fa-angle-up');
								          }
								        });
									});
								</script>
															<div class="b xlarge mt10px mb10px dib"><h2>More Details about New Delhi, Manali and Shimla Tour</h2></div>
															<div class="data mb15px p15px">
								<div class="mb7px"> 
								<p class="b xlarge mb10px dib">Inclusions</p>
								</div>
												
								<ul>
																			<li>MAP (Room + Breakfast + Lunch/Dinner)</li>
																						<li>Hotel</li>
																				<li>Comprehensive Package for 2 Adults 1 Room with MAP for 5 Nights.</li><li>
Welcome drink on arrival (Non Alcoholic i.e. Tea, Coffee, Juice etc.</li><li>
MAP Meal Plan- 5 Breakfasts, 5 Dinner Vegetarian Meal only ( Non vegetarian Meal directly payable at Hotel)</li><li>
Swift Dzire /Toyota Etios Cab from Delhi  to Delhi. </li><li>
CAB for sight-seeing Shimla, Kullu and Manali.</li><li>
Included of all taxes (Parking, Toll Tax, luxury tax, Govt. Service Tax, Fuel Exp. And driver exp.  Etc.</li>
																	</ul>
								</div>
																<div class="data mb15px p15px">
								<div class="mb7px"> 
								<p class="b xlarge mb10px dib">Exclusions</p>
								</div>
								
								<ul><li>Check in time 12:00 Pm & Check out time 12:00 Pm.</li><li>
 Monument entrance fee/ Camera fees.</li><li>
 Any personal expensive -Laundry, Shopping, tip etc.</li><li>
Air and Train Fare</li><li>
  Meal other than specified.</li><li>
Heater charges will be extra.</li></ul>
								</div>
																<div class="data mb15px p15px">            
								<div class="mb7px"> 
								<p class="b xlarge mb10px dib">Rate Card</p>
								</div>
								
    	<p class="h dif xlarge b mb5px">HOTEL DETAILS</p>
    	<div class="otherDetails aj">PACKAGE CATEGORY  & COST</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="data p5px">CATEGORY</td>
				<td class="data p5px">CITY</td>
				<td class="data p5px">NIGHTS</td>
				<td class="data p5px">HOTEL NAME</td>
				<td class="data p5px">PACKAGE COST</td>
			</tr>
			<tr>
				<td class="data p5px">Deluxe 2*</td>
				<td class="data p5px">Shimla</td>
				<td class="data p5px">2 Nights</td>
				<td class="data p5px">Valley View/ Taaz Palace/ Wood Park Similar</td>
				<td class="data p5px">Total Cost        Rs./-33,500</td>
			</tr>
			<tr>
				<td class="data p5px">-</td>
				<td class="data p5px">Manali</td>
				<td class="data p5px">3 Nights</td>
				<td class="data p5px">Nirvana/ Kartikain/Out Town/Similar</td>
				<td class="data p5px">(Include all taxes)</td>
			</tr>
			<tr>
				<td class="data p5px">Deluxe 3*</td>
				<td class="data p5px">Shimla</td>
				<td class="data p5px">2 Nights</td>
				<td class="data p5px">Ameera/Maharaja/Charming Hills /Similar</td>
				<td class="data p5px">Total Cost        Rs./-37,500</td>
			</tr>
			<tr>
				<td class="data p5px">-</td>
				<td class="data p5px">Manali</td>
				<td class="data p5px">3 Nights</td>
				<td class="data p5px">Shaina Mareema/ Day Flower/Abhilashi Residency/ Nasogi Heights</td>
				<td class="data p5px">(Include all taxes)</td>
			</tr>
			<tr>
				<td class="data p5px">Super Deluxe 3*</td>
				<td class="data p5px">Shimla</td>
				<td class="data p5px">2 Nights</td>
				<td class="data p5px">Royal Regency / Bridge View/Similar</td>
				<td class="data p5px">Total Cost        Rs./-43,500</td>
			</tr>
			<tr>
				<td class="data p5px">--</td>
				<td class="data p5px">Manali</td>
				<td class="data p5px">3 Nights</td>
				<td class="data p5px">Snow Peak Retreat/ Avishi Greens/Similar</td>
				<td class="data p5px">(Include all taxes)</td>
			</tr>
			<tr>
				<td class="data p5px">Luxury 4*</td>
				<td class="data p5px">Shimla</td>
				<td class="data p5px">2 Nights</td>
				<td class="data p5px">Twin Towers/ Baljees Regency/Rocky Knob/Similar</td>
				<td class="data p5px">Total Cost        Rs./-55,500</td>
			</tr>
			<tr>
				<td class="data p5px">--</td>
				<td class="data p5px">Manali</td>
				<td class="data p5px">3 Nights</td>
				<td class="data p5px">Allure Grand /Citrus Resort/ Golden Tulip/Similar</td>
				<td class="data p5px">(Include all taxes)</td>
			</tr>
		</table></div><br>								</div>
																<div class="data mb15px p15px">            
								<div class="mb7px"> 
								<p class="b xlarge mb10px dib">Payments Terms</p>
								</div>
								
								<ul><li>No refund will be made for any unused accommodation, missed meals, transportation segments, sightseeing tours or any other service. Such unused items are neither refundable nor exchangeable. </li><li>
Room allocation is done by the hotel depending upon availability at the time of check-in in the category of room as specified on your confirmation voucher. </li><li>
                                                                                                                                                          </li><li>
No refund shall be claimed, if the services & amenities of hotel were not up to your expectations, it will be considered on case to case basis.</li><li>
Service Tax of 9.0% on total package cost inclusive of Swachh Bharat Cess & Krishi Kalyan Cess applicable as on date, for the Tour cost of the Package, service tax rate are subject to change. </li><li>
The GST is under consideration by the Government of India and as and when the same is enacted the same shall be applicable to you without any intimation. </li><li>
 The above Package Cost together with the Service Tax is subject to change w.e.f. the date of implementation of GST (Goods & Services Tax) as and when notified by the Government.</li><li>
 </li><li>
                                                                                                                             </li><li>
                                                                Payment Policy</li><li>
- In the case of a Credit Card Payments, an additional surcharge of 2.5% will be charged extra over the NET payable amount.                                                                                                                                                                                                                                       - In the case of a Debit Card Payments, an additional surcharge of 1% will be charged extra over the NET payable amount.</li><li>
- In the case of an NEFT/RTGS/ Online Transfer no transfer charge will be levied.                                                                                                                                     </li><li>
                                                               Confirmation</li><li>
We would be delighted to plan your holiday and confirm your reservation depending upon the availability from the hotels/ airlines at the time of making payments. For the confirmation of the package you can deposit the amount in any branch of Bank of India.</li><li>
You can deposit by cash, cheque and online in any branch of these banks.</li><li>
Our Bank Details</li><li>
 Bank	Bank Of  India </li><li>
 Name	Rockey Toppo</li><li>
 A/C	958510110000089</li><li>
 IFSC	BKID0009585</li></ul>					
								</div>
														<div class="data mb15px p15px">            
						<div class="mb7px"> 
						<p class="b xlarge mb10px dib">Price &amp; Rates</p>
						</div>				
				        <table cellpadding="10px" cellspacing="0" class="w100 mb10px data" border="1">
				        	<thead class="headVr">
			            	<tr>
			                	<td class="fw6 p10px ac bdr">No of pax</td>
			                    <td class="fw6 p10px ac bdr">Age Limit</td>
			                    <td class="fw6 p10px ac bdr">Price per pax (Rs)</td>
			                </tr>
			                </thead>

															<tr>
				            	<td class="p10px ac bdr">Adult</td>
				                <td class="p10px ac bdr">Above 12 years</td>
				                <td class="p10px ac bdr">
			                				                		<b class="webrupee">INR</b>
			                					                	<b>16249</b> <small>/
			
			                		Adult			
			                				
			                		
			                	</small></td>
				            	</tr>
				            					         </table>
						</div>
					 					
						<div class="data mb15px p15px">            
						<div class="mb7px"> 
						<p class="b xlarge mb10px dib">Accommodation</p>
						</div>				
		
				    	<table cellpadding="10px" cellspacing="0" class="w100 mb10px data" border="1">
						<thead class="headVr"
				    	<tr>
						<td class="fw6 p10px ac bdr">City</td>
						<td class="fw6 p10px ac bdr">Hotel Name</td>
						<td class="fw6 p10px ac bdr">Star Rating</td>
						</tr>
						</thead>
						 
									<tr>
							    	<td class="p10px ac bdr">
							    	Shimla 
							    	</td>
							        <td class="p10px ac bdr fw6">Shimla Palace / Similar</td>
							        <td class="p10px ac bdr">
							        									        	<span class="dib p5px15px theme2 c3px">3 <i class="fa fa-star small ml1px"></i></span>
								        								        </td>
								    </tr>
									 
									<tr>
							    	<td class="p10px ac bdr">
							    	Manali 
							    	</td>
							        <td class="p10px ac bdr fw6">Green Mountain Villa /Similar</td>
							        <td class="p10px ac bdr">
							        									        	<span class="dib p5px15px theme2 c3px">3 <i class="fa fa-star small ml1px"></i></span>
								        								        </td>
								    </tr>
									 
									<tr>
							    	<td class="p10px ac bdr">
							    	Manali 
							    	</td>
							        <td class="p10px ac bdr fw6">Green  Mountain Villa / Similar</td>
							        <td class="p10px ac bdr">
							        									        	<span class="dib p5px15px theme2 c3px">3 <i class="fa fa-star small ml1px"></i></span>
								        								        </td>
								    </tr>
															</tbody>
						</table>
						</div>
													<div class="data mb15px p15px">            
							<div class="mb7px"> 
							<p class="b xlarge mb10px dib">Remarks</p>
							</div>
									
							<ul><li>1.     The rates are subjects to change without any prior notice.</li><li>
                                                                                                                                 </li><li>
2.     Accommodation in the itinerary at the mentioned hotels or the similar hotels.</li><li>
3.     The confirmation is subjects to availability.</li><li>
4.     AC will not work in Hill Stations.</li><li>
5.     Rooms are subject to the availability.  No reservation has been made till date. This is just a quotation. The above rate is valid only for mentioned dates/ month.</li><li>
6.     The above Quotation is only an offer and not confirmation of your bookings. If we are not able to get the original hotels, shall provide equivalent/ alternative hotels.   </li><li>
7.     No refund will be made for any unused accommodation, missed meals, transportation segments, sightseeing tours or any other service due to Bad weather, ill health, Strike, Road blocks or any other factor beyond our Control. Such unused items are neither refundable nor exchangeable.  </li><li>
8.     Base category rooms will be provided in every package category.</li><li>
9.     Extra bed means Extra mattress.</li><li>
10.   Heater charges are extra.</li><li>
11.   The car may or may not have power windows.</li><li>
                                                                                                                       </li><li>
12     IN case of vehicle not going to Rohtang Pass by any kind of new guidelines proposed by NGT-National green tribunal /Supreme court JM TOURS & TRAVELS and OUR GROUND / TRAVEL PARTNERS  will not be responsible in any case.</li><li>
13     If vehicles will be allowed to go to Rohtang pass the guest will have to bear the expenses on his own if he/she wishes to go to Rohtang pass.</li></ul>			
							</div>
													<div class="data mb15px p15px">            
						<div class="mb7px"> 
						<p class="b xlarge mb10px dib">Cancellation &amp; Refund Policy</p>
						</div>
								
						<ul><li>When Cancellation is made </li><li>
Cancellation will be accepted by mail to the operations department of JM TOURS & TRAVELS.</li><li>
60 - 30 Days more prior to the operation of the booked tour 10% of total tour cost</li><li>
30 - 15 Days more prior to the operation of the booked tour  50% of total tour cost</li><li>
15 - 00 Days prior to the operation of the booked tour  100% of total tour cost</li><li>
                                                                                                                    </li><li>
Please note: All cancellation charges will be furthermost subject to the consideration of those engaged in arranging the itinerary. We will use all our powers to erase the cancellation charges and negotiate for the lowest possible charge</li><li>
                                                                                                                                                            </li><li>
Kindly deposit 40% advance in our company’s Account to confirm your tour.</li></ul>			
						</div>
												<div class="data mb15px p15px">            
						<div class="mb7px"> 
						<p class="b xlarge mb10px dib">Packages by Theme</p>
						</div>
													<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="http://www.jmgroupofservices.com/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="http://www.jmgroupofservices.com/honeymoon-holidays-catid.htm" title="Honeymoon Tour Packages">Honeymoon Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="http://www.jmgroupofservices.com/religious-pilgrimage-holidays-catid.htm" title="Religious & Pilgrimage Tour Packages">Religious & Pilgrimage Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="http://www.jmgroupofservices.com/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="http://www.jmgroupofservices.com/lakes-rivers-holidays-catid.htm" title="Lakes & Rivers Tour Packages">Lakes & Rivers Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="http://www.jmgroupofservices.com/house-boat-holidays-catid.htm" title="House Boat Tour Packages">House Boat Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="http://www.jmgroupofservices.com/wildlife-safari-holidays-catid.htm" title="Wildlife Safari Tour Packages">Wildlife Safari Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="http://www.jmgroupofservices.com/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 "><a  href="http://www.jmgroupofservices.com/heritage-holidays-catid.htm" title="Heritage Tour Packages">Heritage Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="http://www.jmgroupofservices.com/camping-holidays-catid.htm" title="Camping Tour Packages">Camping Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="http://www.jmgroupofservices.com/trekking-holidays-catid.htm" title="Trekking Tour Packages">Trekking Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="http://www.jmgroupofservices.com/family-holidays-catid.htm" title="Family Tour Packages">Family Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="http://www.jmgroupofservices.com/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="http://www.jmgroupofservices.com/water-sports-activity-holidays-catid.htm" title="Water Sports Tour Packages">Water Sports Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="http://www.jmgroupofservices.com/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="http://www.jmgroupofservices.com/adventure-holidays-catid.htm" title="Adventure Tour Packages">Adventure Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="http://www.jmgroupofservices.com/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="http://www.jmgroupofservices.com/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="http://www.jmgroupofservices.com/affordable-budget-holidays-catid.htm" title="Affordable & Budget Tour Packages">Affordable & Budget Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="http://www.jmgroupofservices.com/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="http://www.jmgroupofservices.com/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="http://www.jmgroupofservices.com/skiing-holidays-catid.htm" title="Skiing Tour Packages">Skiing Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="http://www.jmgroupofservices.com/romantic-holidays-catid.htm" title="Romantic Tour Packages">Romantic Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="http://www.jmgroupofservices.com/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="http://www.jmgroupofservices.com/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="http://www.jmgroupofservices.com/mountaineering-holidays-catid.htm" title="Mountaineering Tour Packages">Mountaineering Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="http://www.jmgroupofservices.com/monuments-historical-places-holidays-catid.htm" title="Monuments & Historical Places Tour Packages">Monuments & Historical Places Tours</a></span>
														<span class="uu db ar"><a class="showallspan" data-target="show" href="javascript:void(0)" >View More</a></span>
													</div>
												
						<div class="ac mb10px">
						<form class="inquiry-form" name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.jmgroupofservices.com/enquiry-form-10028.htm">
						<input type="hidden" name="subject" value="Shimla Manali Tour Package By Cab - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>							
						<input type="hidden" name="pkg_slno" value="198929"/>
						</form>
						<a href="javascript:void(0);" 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 Shimla Manali Tour Package By Cab. 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="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="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="Shimla Manali Tour Package By Cab - Tour Package"/>
					<input type="hidden" name="allocate_type" value="tour"/>
					<input type="hidden" name="pkg_slno" value="198929"/>
					<input type="hidden" name="current_url" value="http://www.jmgroupofservices.com/holiday-packages/shimla-manali-tour-packageby-cab.htm">
				  	<input type="hidden" name="web_address" value="http://www.jmgroupofservices.com">
				  	<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="http://www.jmgroupofservices.com/thanks.htm">
					<input type="hidden" name="catalog_mi" value="829818">
				  	<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');
					});  
					}
					});  
					</script>
					</div>
					</div>
									
				
				</div>
				
										<br />
						<section class="pt20px pb20px relTour-pkg rel-prop"><br>
						<div class="wrap">      	
						<div class="myTabs mc bdr0 horizontal987 hot bdr0"><div class=""><ul class="fo lsn m0px p0px"><li class="h hd_h2"><div class="ac"><h2 class="hd_NT">Similar Tour Packages for New Delhi, Manali, Shimla</h2></div></li></ul></div><p class="cb"></p>
						<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='http://www.jmgroupofservices.com/holiday-packages/manali3n4d-volvo-package.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/dir_28/829818/335931.jpg"  height=""  width=""    alt="Manali 3N/4D Volvo Package" title="Manali 3N/4D Volvo Package"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="http://www.jmgroupofservices.com/holiday-packages/manali3n4d-volvo-package.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								3 Nights / 4 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="http://www.jmgroupofservices.com/holiday-packages/manali3n4d-volvo-package.htm" title="Manali 3N/4D Volvo Package"><h3>Manali 3n/4d Volvo Package</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='http://www.jmgroupofservices.com/holiday-packages/manali-kasol-tour-packageat-every-friday.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/dir_28/829818/335667.jpg"  height=""  width=""    alt="Manali-Kasol Tour Package At Every Friday" title="Manali-Kasol Tour Package At Every Friday"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="http://www.jmgroupofservices.com/holiday-packages/manali-kasol-tour-packageat-every-friday.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								3 Nights / 4 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="http://www.jmgroupofservices.com/holiday-packages/manali-kasol-tour-packageat-every-friday.htm" title="Manali-Kasol Tour Package At Every Friday"><h3>Manali-kasol Tour Package At Every Friday</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='http://www.jmgroupofservices.com/holiday-packages/shimla-manali-tour-package.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/dir_28/829818/335073.jpg"  height=""  width=""    alt="Shimla-Manali Tour Package" title="Shimla-Manali Tour Package"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="http://www.jmgroupofservices.com/holiday-packages/shimla-manali-tour-package.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="http://www.jmgroupofservices.com/holiday-packages/shimla-manali-tour-package.htm" title="Shimla-Manali Tour Package"><h3>Shimla-manali Tour Package</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='http://www.jmgroupofservices.com/holiday-packages/mumbai-amritsar-mcleodganj-dharamshala-birbilling-kasol-manali-mumbai.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/dir_28/829818/327778.jpeg"  height=""  width=""    alt="Mumbai -amritsar - Mcleodganj - Dharamshala - Birbilling - Kasol - Manali - Mumbai" title="Mumbai -amritsar - Mcleodganj - Dharamshala - Birbilling - Kasol - Manali - Mumbai"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="http://www.jmgroupofservices.com/holiday-packages/mumbai-amritsar-mcleodganj-dharamshala-birbilling-kasol-manali-mumbai.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								10 Nights / 11 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="http://www.jmgroupofservices.com/holiday-packages/mumbai-amritsar-mcleodganj-dharamshala-birbilling-kasol-manali-mumbai.htm" title="Mumbai -amritsar - Mcleodganj - Dharamshala - Birbilling - Kasol - Manali - Mumbai"><h3>Mumbai -amritsar - Mcleodganj - Dharamshala - Birbilling - Kasol - Manali - Mumbai</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='http://www.jmgroupofservices.com/holiday-packages/adventurous-himachal-with-amritsar10-nights11-days.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/dir_28/829818/324368.jpg"  height=""  width=""    alt="Adventurous Himachal With Amritsar 10 Nights / 11 Days" title="Adventurous Himachal With Amritsar 10 Nights / 11 Days"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="http://www.jmgroupofservices.com/holiday-packages/adventurous-himachal-with-amritsar10-nights11-days.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								10 Nights / 11 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="http://www.jmgroupofservices.com/holiday-packages/adventurous-himachal-with-amritsar10-nights11-days.htm" title="Adventurous Himachal With Amritsar 10 Nights / 11 Days"><h3>Adventurous Himachal With Amritsar 10 Nights / 11 Days</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='http://www.jmgroupofservices.com/holiday-packages/9nights-10days-adventurous-tour-package.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/dir_28/829818/322461.jpg"  height=""  width=""    alt="9Nights/10Days  Adventurous Tour Package" title="9Nights/10Days  Adventurous Tour Package"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="http://www.jmgroupofservices.com/holiday-packages/9nights-10days-adventurous-tour-package.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								9 Nights / 10 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="http://www.jmgroupofservices.com/holiday-packages/9nights-10days-adventurous-tour-package.htm" title="9Nights/10Days  Adventurous Tour Package"><h3>9nights/10days  Adventurous Tour Package</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='http://www.jmgroupofservices.com/holiday-packages/shimla-5day-4nights-package.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/dir_28/829818/322483.jpg"  height=""  width=""    alt="Shimla 5Day/4Nights Package" title="Shimla 5Day/4Nights Package"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="http://www.jmgroupofservices.com/holiday-packages/shimla-5day-4nights-package.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								4 Nights / 5 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="http://www.jmgroupofservices.com/holiday-packages/shimla-5day-4nights-package.htm" title="Shimla 5Day/4Nights Package"><h3>Shimla 5day/4nights Package</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='http://www.jmgroupofservices.com/holiday-packages/shimla2n-manali3n-honeymoon-tour-onseason.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/dir_28/829818/319426.jpg"  height=""  width=""    alt="Shimla 2N Manali 3N Honeymoon Tour Onseason" title="Shimla 2N Manali 3N Honeymoon Tour Onseason"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="http://www.jmgroupofservices.com/holiday-packages/shimla2n-manali3n-honeymoon-tour-onseason.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="http://www.jmgroupofservices.com/holiday-packages/shimla2n-manali3n-honeymoon-tour-onseason.htm" title="Shimla 2N Manali 3N Honeymoon Tour Onseason"><h3>Shimla 2n Manali 3n Honeymoon Tour Onseason</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='http://www.jmgroupofservices.com/holiday-packages/manali-kasol-tour-packageby-volvo-bus.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/dir_28/829818/319823.jpg"  height=""  width=""    alt="Manali Kasol Tour Package By Volvo Bus" title="Manali Kasol Tour Package By Volvo Bus"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="http://www.jmgroupofservices.com/holiday-packages/manali-kasol-tour-packageby-volvo-bus.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="http://www.jmgroupofservices.com/holiday-packages/manali-kasol-tour-packageby-volvo-bus.htm" title="Manali Kasol Tour Package By Volvo Bus"><h3>Manali Kasol Tour Package By Volvo Bus</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='http://www.jmgroupofservices.com/holiday-packages/manali-tour-package-for04-nights05-days.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/dir_28/829818/319346.jpg"  height=""  width=""    alt="Manali Tour Package For 04 Nights 05 Days" title="Manali Tour Package For 04 Nights 05 Days"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="http://www.jmgroupofservices.com/holiday-packages/manali-tour-package-for04-nights05-days.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								4 Nights / 5 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="http://www.jmgroupofservices.com/holiday-packages/manali-tour-package-for04-nights05-days.htm" title="Manali Tour Package For 04 Nights 05 Days"><h3>Manali Tour Package For 04 Nights 05 Days</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='http://www.jmgroupofservices.com/holiday-packages/splended-manali-kasoul-leh-tour.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/dir_28/829818/319870.jpg"  height=""  width=""    alt="Splended Manali Kasoul Leh Tour" title="Splended Manali Kasoul Leh Tour"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="http://www.jmgroupofservices.com/holiday-packages/splended-manali-kasoul-leh-tour.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								11 Nights / 12 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="http://www.jmgroupofservices.com/holiday-packages/splended-manali-kasoul-leh-tour.htm" title="Splended Manali Kasoul Leh Tour"><h3>Splended Manali Kasoul Leh Tour</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='http://www.jmgroupofservices.com/holiday-packages/manali-tourby-volvo-bus.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/dir_28/829818/319371.jpg"  height=""  width=""    alt="Manali Tour By Volvo Bus" title="Manali Tour By Volvo Bus"  class="bdr p1px"  /></div></div>
								<div class="absViewBtn"><a href="http://www.jmgroupofservices.com/holiday-packages/manali-tourby-volvo-bus.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								4 Nights / 5 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="http://www.jmgroupofservices.com/holiday-packages/manali-tourby-volvo-bus.htm" title="Manali Tour By Volvo Bus"><h3>Manali Tour By Volvo Bus</h3></a></div>
							</div>
							</div>						
							</li>
															
						</ul>
						</div>
						</div> 
						  
							<script>
							  $(document).ready(function(){			
								$('.bxslider987').bxSlider({
									mode:'horizontal',				
									slideWidth: 214,maxSlides: 10,slideMargin:10,auto: true, 
									autoDirection:'next',
									moveSlides: 1,
									pause:2000,
									pager:false,
									pagerType:'full',
									autoControls: false, 
									controls:true, 
									autoHover:true,				
									speed:1000
								});
							  });
							  </script>
							  							  
						 </div>
					     </div>
					    </section>
										<section class="pt20px pb20px absTour-Title rel-prop"><br>
				<div class="wrap">      	
				<div class="myTabs mc bdr0 horizontal987 hot bdr0"><div class=""><ul class="fo lsn m0px p0px"><li class="h hd_h2"><div class="ac"><h2 class="hd_NT">Explore Tour Packages by Destination</h2></div></li></ul></div><p class="cb"></p>
				<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="http://www.jmgroupofservices.com/manali-tour-packages.htm" title="Manali Tour Packages" ><img src="https://dynamic.tourtravelworld.com/zsc-header/10061-classified.jpg"  height=""  width=""    alt="Manali" title="Manali"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.jmgroupofservices.com/manali-tour-packages.htm" title="Manali Tour Packages">Manali 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="http://www.jmgroupofservices.com/shimla-tour-packages.htm" title="Shimla Tour Packages" ><img src="https://dynamic.tourtravelworld.com/zsc-header/10070-classified.jpg"  height=""  width=""    alt="Shimla" title="Shimla"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.jmgroupofservices.com/shimla-tour-packages.htm" title="Shimla Tour Packages">Shimla 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="http://www.jmgroupofservices.com/manikaran-tour-packages.htm" title="Manikaran Tour Packages" ><img src="https://dynamic.tourtravelworld.com/zsc-header/10063-classified.jpg"  height=""  width=""    alt="Manikaran" title="Manikaran"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.jmgroupofservices.com/manikaran-tour-packages.htm" title="Manikaran Tour Packages">Manikaran 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="http://www.jmgroupofservices.com/kullu-tour-packages.htm" title="Kullu Tour Packages" ><img src="https://dynamic.tourtravelworld.com/zsc-header/10059-classified.jpg"  height=""  width=""    alt="Kullu" title="Kullu"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.jmgroupofservices.com/kullu-tour-packages.htm" title="Kullu Tour Packages">Kullu 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="http://www.jmgroupofservices.com/srinagar-tour-packages.htm" title="Srinagar Tour Packages" ><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="http://www.jmgroupofservices.com/srinagar-tour-packages.htm" title="Srinagar Tour Packages">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="http://www.jmgroupofservices.com/new-delhi-tour-packages.htm" title="New Delhi Tour Packages" ><img src="https://dynamic.tourtravelworld.com/zsc-header/10009-classified.jpg"  height=""  width=""    alt="New Delhi" title="New Delhi"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.jmgroupofservices.com/new-delhi-tour-packages.htm" title="New Delhi Tour Packages">New Delhi 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="http://www.jmgroupofservices.com/pahalgam-tour-packages.htm" title="Pahalgam Tour Packages" ><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="http://www.jmgroupofservices.com/pahalgam-tour-packages.htm" title="Pahalgam Tour Packages">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="http://www.jmgroupofservices.com/mumbai-tour-packages.htm" title="Mumbai Tour Packages" ><img src="https://dynamic.tourtravelworld.com/zsc-header/10355-classified.jpg"  height=""  width=""    alt="Mumbai" title="Mumbai"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.jmgroupofservices.com/mumbai-tour-packages.htm" title="Mumbai Tour Packages">Mumbai 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="http://www.jmgroupofservices.com/havelock-tour-packages.htm" title="Havelock Tour Packages" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/331995.jpg"  height=""  width=""    alt="Havelock Tour Packages" title="Havelock Tour Packages"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.jmgroupofservices.com/havelock-tour-packages.htm" title="Havelock Tour Packages">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="http://www.jmgroupofservices.com/north-goa-tour-packages.htm" title="North Goa Tour Packages" ><img src="https://ttw.wlimg.com/package-images/photo-small/dir_28/829818/331987.jpg"  height=""  width=""    alt="North Goa Tour Packages" title="North Goa Tour Packages"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.jmgroupofservices.com/north-goa-tour-packages.htm" title="North Goa Tour Packages">North Goa 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="http://www.jmgroupofservices.com/port-blair-tour-packages.htm" title="Port Blair Tour Packages" ><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="http://www.jmgroupofservices.com/port-blair-tour-packages.htm" title="Port Blair Tour Packages">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="http://www.jmgroupofservices.com/goa-city-tour-packages.htm" title="Goa City Tour Packages" ><img src="https://dynamic.tourtravelworld.com/zsc-header/11555-classified.jpg"  height=""  width=""    alt="Goa City" title="Goa City"  /></a></div></div>
					<div class="h xlarge fw6 lh15em"><a href="http://www.jmgroupofservices.com/goa-city-tour-packages.htm" title="Goa City Tour Packages">Goa City 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><br><br>
				</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:72:"Book Shimla Manali Tour Package By Cab - 5 Nights / 6 Days Tour Packages";i:2;s:152:"book shimla manali tour package by cab - 5 nights / 6 days tour packages, hill stations & valleys tour packages, new delhi, manali, shimla tour packages";i:3;s:202:"Book Shimla Manali Tour Package By Cab - 5 Nights / 6 Days tour packages from JM Tours & Travels - Get attractive 5 Nights / 6 Days Hill Stations & Valleys  tour packages for  New Delhi, Manali, Shimla.";i:4;s:988:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "New Delhi, Manali, Shimla"        
		                 },
		      "description": "Travel Date                                               Season Rate 
        No of Pax                                                   2 Adults 
        Pick up Point                                              Delhi
        Drop Point                                                  Delhi
        Destination                                                Shimla-Kullu–Manali
        Vehicle offered                                          Swift Dzire/ Toyota Etios 
        Rooms                                                        1 Room",
		      "name": "Shimla Manali Tour Package By Cab",
		      "telephone": "+91-7987782662"
		    }
		    </script>
			";i:5;N;}