a:7:{i:0;s:112888:"				<section id="middle" class="propDtls ttwBtmFtSpace">
				<div class="wrap thinFormat " id="bodyFormatNT">
									<div class="ar small fo"><a href="https://www.cmoretravels.in/" title="Home">Home</a>
					
											<b class="ffv p2px">&rsaquo;</b> <a href="https://www.cmoretravels.in/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
											
					<b class="ffv p2px">&rsaquo;</b> <span class="alpha75">Taj, Temple & Ganges Tour</span></div> 
									
				<div class="row1 dt columns23"><!--MIDDLE ROW1 STARTS-->
				<div class="col-2 wideColumn ip ls"><!--MIDDLE ROW1 COL-2 STARTS-->				
								
						<script language="javascript"> 
							function topDestinationToggle(showHideDiv, switchTextDiv) {
							var ele = document.getElementById(showHideDiv);
							var text = document.getElementById(switchTextDiv);
							if(ele.style.display == "block") {
								ele.style.display = "none";
							  text.innerHTML = "View More &#9660;";
							}
							else {
							  ele.style.display = "block";
							  text.innerHTML = "View Less &#9650;";
							}
							}
		                </script>
											<script type="text/javascript">			
					(function($){	
					  $(function(){
						$('[id^=detailslider]').each(function(){
							$(this).DG_Slider({
								auto: true, mode:'fade', pager:true, pagerType:'short',controls:true
							});
						})
				
						$('a[rel=gall]').fancybox()
					  });	
					}(jQuery))
					</script>
				
					<div class="data mb15px mt15px p10px"> 
	 				<div class="fo dt w100"> 	 				
	 											<div class="dtc vat ttw-detail pr20px pr">
							<div class="headVr bdr0">
							<ul class="lsn gallery-slide" id="bxlider_ins">
																	<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/176013.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/176013.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/176013.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></div></a></div></div></li>
																				<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220801.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220801.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220801.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></div></a></div></div></li>
																				<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220800.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220800.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220800.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></div></a></div></div></li>
																				<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220799.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220799.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220799.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></div></a></div></div></li>
																				<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220798.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220798.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220798.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></div></a></div></div></li>
																				<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220797.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220797.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220797.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></div></a></div></div></li>
																				<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220796.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220796.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220796.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></div></a></div></div></li>
																				<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220795.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220795.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220795.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></div></a></div></div></li>
																				<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/176021.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/176021.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/176021.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></div></a></div></div></li>
																				<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/176020.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/176020.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/176020.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></div></a></div></div></li>
																				<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/176018.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/176018.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/176018.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></div></a></div></div></li>
																				<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/176017.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/176017.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/176017.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></div></a></div></div></li>
																				<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/176016.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/176016.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/176016.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></div></a></div></div></li>
																				<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/176014.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/176014.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/176014.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></div></a></div></div></li>
																				<li><div class="imgFrame m0a dib bdr"><div class="imgFrame picBg dtc ac vam lh0"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/241568.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/241568.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/241568.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></div></a></div></div></li>
																	</ul>
															<ul class="lsn" id="bxslider-pager">
																	<li data-slideIndex="0"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/176013.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></a></li>
																		<li data-slideIndex="1"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220801.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></a></li>
																		<li data-slideIndex="2"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220800.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></a></li>
																		<li data-slideIndex="3"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220799.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></a></li>
																		<li data-slideIndex="4"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220798.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></a></li>
																		<li data-slideIndex="5"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220797.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></a></li>
																		<li data-slideIndex="6"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220796.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></a></li>
																		<li data-slideIndex="7"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220795.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></a></li>
																		<li data-slideIndex="8"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/176021.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></a></li>
																		<li data-slideIndex="9"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/176020.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></a></li>
																		<li data-slideIndex="10"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/176018.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></a></li>
																		<li data-slideIndex="11"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/176017.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></a></li>
																		<li data-slideIndex="12"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/176016.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></a></li>
																		<li data-slideIndex="13"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/176014.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></a></li>
																		<li data-slideIndex="14"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/241568.jpg"  height="150"  width="150"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" ></a></li>
																	</ul>
																<script>
								var realSlider= jQuery("ul#bxlider_ins").bxSlider({
								speed:500,
								pager:false,
								auto: true,
								slideWidth: 450,
								slideMargin: 0,
								nextText:'',
								prevText:'',
								infiniteLoop:true,
								hideControlOnEnd:true,
								onSlideBefore:function($slideElement, oldIndex, newIndex){
								changeRealThumb(realThumbSlider,newIndex);
								
								}
								
								});
								
								var realThumbSlider=jQuery("ul#bxslider-pager").bxSlider({
								minSlides: 4,
								maxSlides: 4,
								slideWidth: 115,
								slideMargin: 5,
								moveSlides: 1,
								pager:false,
								auto:false,
								speed:1000,
								infiniteLoop:false,
								hideControlOnEnd:false,
								nextText:'<span></span>',
								prevText:'<span></span>',
								onSlideBefore:function($slideElement, oldIndex, newIndex){
								
								}
								});
								
								linkRealSliders(realSlider,realThumbSlider);
								
								if(jQuery("#bxslider-pager li").length<5){
								jQuery("#bxslider-pager .bx-next").hide();
								}
								
								// sincronizza sliders realizzazioni
								function linkRealSliders(bigS,thumbS){
								
								jQuery("ul#bxslider-pager").on("click","a",function(event){
								event.preventDefault();
								var newIndex=jQuery(this).parent().attr("data-slideIndex");
								bigS.goToSlide(newIndex);
								});
								}
								
								//slider!=$thumbSlider. slider is the realslider
								function changeRealThumb(slider,newIndex){  
								var $thumbS=jQuery("#bxslider-pager");
								$thumbS.find('.active').removeClass("active");
								$thumbS.find('li[data-slideIndex="'+newIndex+'"]').addClass("active");
								
								if(slider.getSlideCount()-newIndex>=4)slider.goToSlide(newIndex);
								else slider.goToSlide(slider.getSlideCount()-4);
								
								}
								</script>
															</div>
							</div>
												<div class="dtc pt7px ttwDtlsCont">
					<div class="adrsDtls">
											<h1>Taj, Temple & Ganges Tour</h1>
											<div class="ShareDropdown">		
					<div class="copyLinkPopup">Link Copied</div>	  
					<span class="data"><i class="fa fa-share-alt xxlarge vam"></i></span>
					<ul class="shareList data bdr0">
					<li><a target="_blank" href="https://www.facebook.com/sharer/sharer.php?u=https://www.cmoretravels.in/tour-packages/taj-temple-ganges-tour.htm" class="facebook" title="Facebook"><i class="fa fa-facebook-official"></i></a></li> 
					<li><a target="_blank" href="https://www.instagram.com/?url=https://www.cmoretravels.in/tour-packages/taj-temple-ganges-tour.htm" class="instagram" title="Instagram"><i class="fa fa-instagram"></i></a></li>
					<li><a target="_blank" href="https://wa.me/?text=https://www.cmoretravels.in/tour-packages/taj-temple-ganges-tour.htm" class="whatsapp" title="Whatsapp"><i class="fa fa fa-whatsapp"></i></a></li>  
					<li><a target="_blank" href="https://twitter.com/intent/tweet?text=Taj, Temple & Ganges Tour&url=https://www.cmoretravels.in/tour-packages/taj-temple-ganges-tour.htm" class="twitter" title="Twitter"><img src="https://catalog.wlimg.com/mobile/social-networking-img/1002.svg" alt="Twitter" style="width:22px;height:22px;vertical-align:middle;margin-right:6px;"></a></li> 
					<li><a target="_blank" href="https://www.linkedin.com/shareArticle?mini=true&url=https://www.cmoretravels.in/tour-packages/taj-temple-ganges-tour.htm&title=Taj, Temple & Ganges Tour" class="linkedin" title="Linkedin"><i class="fa fa-linkedin-square"></i></a></li>
					<li><a target="_blank" href="https://pinterest.com/pin/create/button/?url=https://www.cmoretravels.in/tour-packages/taj-temple-ganges-tour.htm&description=Taj, Temple & Ganges Tour" class="pinterest" title="Pinterest"><i class="fa fa-pinterest-square"></i></a></li>
					<li><a href="javascript:;" title="Copy Link" class="copy" onclick="copyURL()"><i class="fa fa-clone"></i></a></li>
					</ul>
					</div>
					</div>
					<script>
					$(document).ready(function(){
					$('.ShareDropdown span').click(function(){
					 $('.ShareDropdown').toggleClass("active");
					}); 
					});
					</script>
					<script>
					  function copyURL() {
					    const url = window.location.href;
						const textarea = document.createElement("textarea");
						textarea.value = url;
						textarea.style.position = "fixed";
						document.body.appendChild(textarea);
						textarea.focus();
						textarea.select();
				
						try {
						  document.execCommand("copy");
						//  alert("URL copied (fallback)!");
						  $(".copyLinkPopup").show();		 
				          setTimeout(function(){$(".copyLinkPopup").hide();}, 2000);
					      $('.ShareDropdown').removeClass("active");
						  
						} catch (err) {
						  console.error("Fallback copy failed:", err);
						}
				
						document.body.removeChild(textarea);
					  }
					</script>
											<p class="mb5px"><b>Tour Code :</b> CI</p>
												<p class="mb5px"><b>Duration :</b> 
						9 Nights / 10 Days 
						</p>
												<p class="mb5px"><b>Destination Covered :</b> New Delhi, Jaipur, Agra, Jhansi, Khajuraho, Varanasi, Vishwanath Temple, Khajuraho, Jaigarh Fort, Hawa Mahal, Taj Mahal, Kashi Vishwanath Temple, Buland Darwaza, Fatehpur Sikri, Qutab Minar, Amber Fort, City Palace, India Gate, Lotus Temple, Jantar Mantar, Jantar Mantar</p>
												<p class="mb5px"><b>Tour Activities :</b> Adventure, Affordable & Budget, Ship & Cruise, Festive & Events, Family, Food and Drink, Forts and Palaces, Group, Heritage, Honeymoon, Romantic, Religious & Pilgrimage, Lakes & Rivers, Road Trip, Shopping, Winter, Yoga & Meditation</p>
												<p class="mb5px"><b>Tour Themes : </b>Religious & Pilgrimage</p>
												<p class="mb5px"><b>Special Offer :</b> 10% DISCOUNT on published price, in case tour is booked & paid for 90 days prior to tour arrival date subject to minimum 2 persons travelling together.</p>
												<div class="fo mt20px mb20px ac xxlarge">
          				<p class="xxlarge b dif mb2px">
						USD 899						</p>
						<p class="xxsmall alpha50">Per Person</p>
          				</div>
											<div class="ac">
					<form class="inquiry-form" name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.cmoretravels.in/enquiry-form-10028.htm">
					<input type="hidden" name="subject" value="Taj, Temple & Ganges Tour - Tour Package"/>
					<input type="hidden" name="allocate_type" value="tour"/>							
					<input type="hidden" name="pkg_slno" value="105789"/>
					</form>
					<a href="javascript:;" class="submit-inquiry button p10px20px c5px ts0 xlarge dib fw6">Inquire Now for Best Deals</a>
					
										</div>
					<br />
										</div>
	   				</div>
					</div>
											<div class="mt7px dif small mb15px">* Mentioned prices may vary depending upon date of travel, hotel availability, surge pricing and seasonal rush.</div>
														<section id="s1">
								<div class="data mt20px mb20px m_p25px lh2em">      
								<div class="xxlarge mb10px">
												   					<h2 class="fw7">New Delhi, Jaipur and Agra Tour Overview</h2>
				   													</div>
								<p class="large">					
								Classical India Tour is one of the most sought after programs for any tourist visiting India. Classical India tour lets you catch a glimpse of immensely beautiful destinations of north India. Be it the beautiful architectural city of Jaipur built of Red sandstone or one of the wonders of the world - the Taj Mahal either the visit to the temple of Kamasutra - Khajuraho or the boat ride on the Ganges river in the ancient city of Varanasi when the dawn hovers, name one beautifully exotic and spectacular destination, and north India never fails to surprise you with what it has store in for you. Spread over the span of eight days this tour lets you surrender in the tranquility of north India. Pack your bags and this tour would be the most cherished travel experience.10% DISCOUNT on published price, in case tour is booked & paid for 90 days prior to tour arrival date subject to minimum 2 persons travelling together.Breakfast on day of arrival<br />
Meals where not mentioned<br />
Medical & personal expenses like beverages<br />
Tips and gratitude’s, telecommunication charges<br />
Wi-Fi service<br />
Laundry and what so ever not mentioned under “cost Includes1-1031-3								</p>
								</div>
								</section>
																<section id="s2" class="mt15px">
								<div class="data mb20px m_p25px">
		  						<div class="fw7 xxlarge">
		  										   					<h2 class="fw7">New Delhi, Jaipur and Agra Tour Itinerary</h2>
				   							  						</div>
					            <div class="tour-details-view mt22px">
					            
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 1</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px on"><a href="javascript:;" class="clickable db"><h3>Arrive Delhi</h3>
										<span class="fr pr10px"><i class="fa fa-angle-up"></i></span></a>
										</div>
										<div class="pro-detail mb15px ">
											<div class="frwm lh0 pr">
			 								<span class="itnry-zoom dib">
													<a  data-fancybox="showZoomImage1" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220795.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220795.jpg"  height="200"  width="200"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;" loading="lazy" ></a>
											</span> 
											</div>Arrive Delhi at Terminal 3 of Indira Gandhi International Airport. You are greeted and escorted by our company representative to your Hotel by your personal chauffeur. Overnight stay - (Check -in 1400 hrs).
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 2</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Delhi</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px 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_14/401707/220796.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220796.jpg"  height="200"  width="200"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;" loading="lazy" ></a>
											</span> 
											</div>Delhi: Morning enjoy a luxurious & relaxed breakfast. Later at 1000 hrs proceed for guided tour of Old Delhi. Begin your tour visiting the Lotus Temple. Next proceed towards Old Town to explore the magnificent Red Fort, built at the zenith of the Mughal Empire in India. The centuries- old international market- place that sprawls at its feet is still one of Delhi’s most important commercial hubs: Chandni Chowk, or as also known as the “Moonlight Square”. Walk through the bustling silver market and the wholesale spice market. The sounds, smells and colors of the bazaar, and the throngs of people who animate it make this an unforgettable spectacle. Visit Jumma Masjid, the largest mosque in Asia and Raj Ghat - Final resting place of Mahatma Gandhi, before returning to hotel for Overnight stay in the hotel.					
											<div class="mt10px"><b>Meals : </b> Breakfast</div>
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 3</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Delhi - Jaipur</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px 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_14/401707/220797.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220797.jpg"  height="200"  width="200"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;" loading="lazy" ></a>
											</span> 
											</div>Delhi to Jaipur - Morning after breakfast, depart by surface for the City of Jaipur - an exuberance of colors, dance & song with traditional arts and crafts. Known, as the 'Pink City', it is one of India's most well planned cities with wide straight avenues, roads, streets and lanes in a grid system. A 6 hour’s drive gets us to this land of Maharaja's, forts & Palaces. Later on arrival at your Hotel, you will be met by our company representative who will facilitate your check in at the hotel.<br />
<br />
Afternoon 1500 hrs is reserved for guided sightseeing tour of the City Palace situated in the heart of the old City, The City Palace SMS Museum and Jai Singh's observatory also called “Jantar Mantar” built in the18th century by Maharaja Sawai Jai Singh II, where huge Masonry instruments were used to study the movement of constellations and Stars in the sky. Drive past Hawa Mahal (Palace of winds) built in 1799, by Maharaja Sawai Pratap Singh, is the most recognizable monument of Jaipur. Stop here for photos. Return to your hotel for Overnight stay in hotel.					
											<div class="mt10px"><b>Meals : </b> Breakfast</div>
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 4</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Jaipur</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px 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_14/401707/220798.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220798.jpg"  height="200"  width="200"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;" loading="lazy" ></a>
											</span> 
											</div>Japur Morning after breakfast, proceed for Half Day guided excursion to see two of the most impressive forts of Rajasthan. Visit the impressive Amber Fort the former capital of the Royal Family of Jaipur. On arrival mount an elephant to ride to the main entrance of the fort located on a hilly mountain top. Next visit Jaigarh Fort. Jaigarh built in 1726, has the world’s largest cannon on wheels, while Nahargarh built in 1734 provides a panoramic view of the Jaipur city. Return to hotel (Those who do not want to ride an elephant can walk up to the fort) - (2 persons per elephant) In case Elephants are not available Jeeps will be used.<br />
<br />
Afternoon is reserved for shopping. Explore the exotic & colorful markets, handicraft & jewellery shops, clothes and boutiques of Jaipur. Return to your hotel for overnight stay.					
											<div class="mt10px"><b>Meals : </b> Breakfast</div>
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 5</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Jaipur - Fatehpur Sikri - Agra</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px 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_14/401707/220799.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220799.jpg"  height="200"  width="200"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;" loading="lazy" ></a>
											</span> 
											</div>Jaipur -Fatehpur Sikri -Agra: Morning after breakfast, depart by surface(5 hours) for the Mughal splendor of Agra, en-route stopping to visit Fatehpur Sikri, the ghost city lying 35 km from Agra. Fatehpur Sikri built in red sandstone in honor of Saint Salim Chisti, who foretold the birth of 3 sons to Emperor Akbar, is an example of robust stability combined with originality. Each important edifice here represents a type by itself. Notable among them is the Diwan- e- Khas, Punch Mahal, the Tomb of Salim Chisti, and the Buland Darwaza. Later drive on to Agra and check-in to your hotel. <br />
<br />
Late afternoon is reserved for a visit the incomparable Taj Mahal. Situated on the banks of river Yamuna, the monumental beauty has inspired countless people around the world and is a fine example of fusion of many architectural styles. It is one of the wonders of the modern world. Built in the year 1652 by Emperor Shah Jahan to immortalize the memory of his beloved wife Mumtaz Mahal, who died tragically in 1631. It took 22 years and 20,000 skilled artisans to complete this poem in white marble. Proceed on Tongas (horse driven chariots) to this magnificent monument of love to Witness sunset before returning to your hotel for overnight stay.					
											<div class="mt10px"><b>Meals : </b> Breakfast</div>
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 6</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Agra - Jjansi- Orchha – Khajuraho</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px dn">Early morning transfer to Agra Railway Station to board superfast Shatabdi Express at 0802 hrs for Jhansi. Breakfast will be served on board the train. Later on arrival at 10.44hrs, you are greeted and escorted by our Jhansi associate’s representative to your waiting vehicle to begin your journey to the City of Orchha in the Tikamgarh district of Madhya Pradesh. A 40 minutes’ drive brings us to this historically important city.<br />
<br />
On arrival proceed for a guided sightseeing tour of the medieval city and erstwhile capital city of the redoubtable Bundela kings. Bordered by the beautiful Betwa River, Orchha reflects the sumptuousness & magnificence of the mighty Bundelas. With its striking forts, regal palaces, poetry carved temples and chhatris; Orchha presents a matchless spectacle and is a delightful place for photographers. Orchha is renowned for its world class Mural Paintings.<br />
<br />
Complete sightseeing and proceed for lunch at Amar Mahal. The Old palace, which still stands high depicting the tales of bygone era, was once witness to the grand royal stories. Enjoy your Lunch with a panoramic view of the monuments, surrounding hills and wildlife sanctuary.<br />
<br />
After lunch proceed by surface for Khajuraho – also called the “land of the moon god” is located at a distance of 172 Kms and is a 3.5 hrs drive. The temples of Khajuraho were built sometime between 950 to 1050 A.D. during the Rajput Chandela dynasty of Central India (These rulers claimed descent -from the moon, hence the name Chandela). Khajuraho is a UNESCO World Heritage Site and is known for its enormous, intricately sculptured temples adorned by vignettes of passion, eroticism, dance, music and creative pursuits. Later on arrival, transfer to your hotel. Balance day is at leisure. Overnight stay.					
											<div class="mt10px"><b>Meals : </b> Breakfast, Lunch</div>
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 7</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Khajuraho – Sarnath - Varanasi</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px dn">Morning after Breakfast proceed for Half Day guided sightseeing tour of the Western Group of Temples, containing the magnificent Shaivite temple Kandariya Mahadeva. Khajuraho’s art is a manifestation of the essence of the philosophy of Indian aesthetics. The erotic sculptures depicting Kama Sutra are unique in the world. They cannot be passed off as just erotic sculptures; the temples have some of the most revered Gods of Hinduism. Some of the other famous temples you will see in the complex are the Lakshmana & the Vishwanath Temple. <br />
Return to your hotel. Later on time, transfer to Khajuraho Airport to board the afternoon flight to Varanasi. Later on arrival you are greeted and escorted by our Varanasi associate’s representative to your waiting vehicle for transfer to Varanasi town <br />
En-route to the hotel, we take a slight detour to visit the ancient city of Sarnath where Buddhism first made its appearance nearly 2500 years ago and where Lord Buddha gave his first sermon to his 5 disciples. Also visit the museum before continuing your journey to Varanasi hotel. On arrival complete check in formalities.<br />
Evening ride on cycle rickshaws’ to the Ghats to witness Aarti (Pooja) ceremony performed at the Ghats, of the Ganges River. Return to your hotel for Overnight stay.					
											<div class="mt10px"><b>Meals : </b> Breakfast</div>
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 8</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Varanasi - Delhi</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px dn">
											<div class="frwm lh0 pr">
			 								<span class="itnry-zoom dib">
													<a  data-fancybox="showZoomImage8" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220800.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220800.jpg"  height="200"  width="200"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;" loading="lazy" ></a>
											</span> 
											</div>Early morning before sunrise, transfer to the Ghats to take an unforgettable boat ride on the Ganges. Since time immemorial, millions of pilgrims arrive every year in Banaras, in search of salvation in the waters of the holy river Ganges. At the crack of dawn, they become a thousand spots of color bathed in the golden waters of the Ganges. The scene on the bathing Ghats is quite fascinating to the western eye. Yogis meditate in impossible positions. Brahmins sit under mushroom-like umbrellas, to bless everyone for a fee. Men and women in various stages of wetness reverently launch little oil-lamps on to the water. Bursts of religious song mingle with the tolling of temple bells, and the rhythmic beat of washer men pounding the city’s laundry. Cruise past different Ghats built by kings and noblemen and the burning Ghats, and watch sunrise before returning to hotel for Breakfast. <br />
<br />
After Breakfast, proceed for Half Day guided sightseeing tour of the Varanasi. This ancient city situated on the banks of river Ganges, in the State of Uttar Pradesh is believed to be more than 2500 years old and is the only city in the world that is still flourishing in its full form. Earlier known as Kashi, which finds mention in the ancient Indian texts of Upanishads and Puranas, Varanasi is believed to have been established by King Kashya in around 1200 BC. <br />
<br />
A guided visit takes you to see the Banaras Hindu University campus commonly referred to as BHU; formerly known as Central Hindu College, is a public central university and is one of the largest residential universities in Asia, with over 20,000 students. Visit the Bharat Kala Bhawan- a museum Of international importance. Next we visit the Temples of Bharat Mata, Kashi Vishwanath (Shiva) and Durga Mata. Wander in the narrow by lanes of the old town before returning to your hotel for Lunch. (Please note: foreigners and non -Hindus are not allowed inside Kashi Vishwanath Temple)<br />
<br />
Later on time transfer to Varanasi Airport to board a late afternoon or early evening flight to Delhi. On arrival, assistance and transfer to your hotel for overnight stay.					
											<div class="mt10px"><b>Meals : </b> Breakfast</div>
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 9</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Delhi</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px dn">
											<div class="frwm lh0 pr">
			 								<span class="itnry-zoom dib">
													<a  data-fancybox="showZoomImage9" href="https://ttw.wlimg.com/package-images/photo-big/dir_14/401707/220801.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/220801.jpg"  height="200"  width="200"    alt="Taj, Temple & Ganges Tour" title="Taj, Temple & Ganges Tour" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;" loading="lazy" ></a>
											</span> 
											</div>Morning after breakfast, proceed for Half Day guided tour of New Delhi. The buildings designed by Edward Lutyens, architect of modern Delhi - are truly majestic. The Presidential Palace, Parliament House and India Gate are all reminiscent of the British “Raj”. Drive through Delhi’s beautiful tree-lined avenues and the Diplomatic Enclave en route to the 12th century, 234-foot high fluted minaret of Qutab Minar. Your tour will terminate with a visit to Humayun’s Tomb where rests the remains of the second Mughal Emperor to rule India. Return to hotel for Lunch.<br />
<br />
Afternoon after lunch, day is free for own activities. This time can be utilized for shopping if you so desires. Overnight stay in the hotel.					
											<div class="mt10px"><b>Meals : </b> Breakfast</div>
										</div> 
										</div>  
			 							</div>
										<div class="iti-box large">
		   								<div class="dayIni dif lh15em">Day 10</div>
		   								<div class="iti-dtls lh18em"> 
   										<div class="sub-title large fw6 db bdrB bdreee pb7px mb10px "><a href="javascript:;" class="clickable db"><h3>Depart Delhi</h3>
										<span class="fr pr10px"><i class="fa fa-angle-down"></i></span></a>
										</div>
										<div class="pro-detail mb15px dn">Depart Delhi:In time departure transfer to Indira Gandhi International airport –Terminal 3 to connect your outbound flight for onward destination (Room Checkout 12 Noon).
										</div> 
										</div>  
			 							</div>								</div>
								</div>
								<script>
								jQuery('.fancybox').fancybox();
								  jQuery(document).ready(function() {
								  jQuery('[data-fancybox]').fancybox({
								  thumbs : {
								  autoStart : true,
								  axis      : 'x'
								  }
								  });
								});
								</script>
								<script>
								jQuery(document).ready(function() {
								//jQuery('.tour-details-view .pro-detail').css('display','none');
								jQuery(".tour-details-view .sub-title").click(function(){
									var $this = jQuery(this);
									  jQuery('.w-title').addClass('h15px',400);
									  $this.find('.w-title').removeClass('h15px',400);
									  if($this.hasClass('on')){
										$this.removeClass('on');
										$this.next().slideUp();          	
									  } else {
										jQuery(".tour-details-view .sub-title").removeClass('on');
										jQuery('.tour-details-view .pro-detail').slideUp();
										$this.addClass('on');
										$this.next().slideDown(); 
									  }		  
									  if($this.find('.tour-details-view i').hasClass('fa-angle-up')){
										$this.find('.tour-details-view i').removeClass('fa-angle-up').addClass('fa-angle-down');
									  } else {
										$this.find('.tour-details-view i').removeClass('fa-angle-down').addClass('fa-angle-up');
									  }
									});
								});
								</script>
								</section>
															<div class="xxlarge mt10px mb10px dib">
										   					<h2 class="fw7">More Details about New Delhi, Jaipur and Agra Tour</h2>
			   												</div>
															<section id="s3">
								<div class="data mb20px m_p25px large">
								<div class="mb7px"> 
								<p class="fw7 xxlarge mb10px dib">Inclusions</p>
								</div>
												
								<ul>
																			<li>Hotel</li>
																						<li>Flights</li>
																						<li>Sightseeing</li>
																						<li>Transfers</li>
																						<li>Pickup-Drop</li>
																						<li>Private Cab</li>
																						<li>Private Guide</li>
																						<li>Entry Tickets/Passes</li>
																						<li>Accommodation</li>
																						<li>Veg & Non Veg Meals</li>
																				<li>9 Nights’ Accommodation in standard (Base) category Double AC rooms on twin sharing basis with private attached toilet & bath in 3/ 4 or 5 star hotels on room & breakfast basis</li><li>
Transportation at all places using 1 medium size sedan AC car for the entire duration of the tour starting from & finishing in Delhi covering Jaipur, Agra, Jhansi-Orcha, Khajuraho & Varanasi including arrival / departure transfers, at all places as mentioned in tour itinerary.</li><li>
Railway AC Chair Car train tickets (inclusive of breakfast) for travel Agra to Jhansi</li><li>
Elephant ride in Jaipur (Amber Fort) -1 elephant to accommodate 2 persons. In case of Non Availability Jeeps will be used.</li><li>
Sightseeing & Excursions as per tour itinerary using one air -conditioned car</li><li>
Services of an accompanied local English-speaking guide during sightseeing </li><li>
2 time Tonga ride to Taj Mahal & Back</li><li>
1 time boat ride on the Ganges in Varanasi</li><li>
1 time Rickshaw ride to witness evening Aarti at Varanasi</li><li>
Entrance charges at all monuments of visit as mentioned in the tour itinerary</li><li>
All presently applicable Central & State Government Taxes on hotels, road, toll & bridge. It is also inclusive of VAT, driver’s daily allowance, parking charges, gasoline, and vehicle insurance.</li><li>
Service Charges for C'MORE for preparing & Executing the tour program.</li>
																	</ul>
								</div>
								</section> 
																<section id="s4">
								<div class="data mb20px m_p25px large">
								<div class="mb7px"> 
								<p class="fw7 xxlarge mb10px dib">Exclusions</p>
								</div>
								
								<ul><li>Breakfast on day of arrival</li><li>
Meals where not mentioned</li><li>
Medical & personal expenses like beverages</li><li>
Tips and gratitude’s, telecommunication charges</li><li>
Wi-Fi service</li><li>
Laundry and what so ever not mentioned under “cost Includes</li></ul>
								</div>
								</section>
																<section id="s5">
								<div class="data mb20px m_p25px large">
								<div class="mb7px"> 
								<p class="fw7 xxlarge mb10px dib">Specific Departure Dates</p>
								</div>
								
								As per clients convenience. Open 365 days a year								</div>
								</section>
																<section id="s6">
								<div class="data mb20px m_p25px large">
								<div class="mb7px"> 
								<p class="fw7 xxlarge mb10px dib">Departure Cities with rates</p>
								</div>
								Delhi								</div>
								</section>
																<section id="s7">
								<div class="data mb20px m_p25px large">          
								<div class="mb7px"> 
								<p class="fw7 xxlarge mb10px dib">Payments Terms</p>
								</div>
								
								<ul><li>We accept credit cards via PayPal and direct bank transfers.</li><li></li><li>
	All remittances by foreign nationals should be via credit card OR via direct Bank wire -transfer from sender’s bank to recipient’s bank account in New Delhi with copy of confirmation sent to us.</li><li></li><li>
	Please note there will be 5.5% surcharge applicable on Total Bill if paying via PayPal</li></ul>					
								</div>
								</section>
									
								<section id="s8">
								<div class="data mb20px m_p25px large">            
								<div class="mb7px"> 
								<p class="fw7 xxlarge mb10px dib">Terms &amp; Conditions</p>
								</div>				
								<ul>
	<li>C&#39;MORE &quot;The Company&quot; accepts bookings subject to the following conditions: On confirmation of the programme from the &quot; Company &quot; a deposit equal to 50% (fifty) of the contracted value of the tour price is required to be sent directly to the &quot;Company&#39;s&quot; bankers, vide swift transfer, with a confirmation copy of the same to the &quot;Company&#39;s &quot; headquarters, at New Delhi. The balance of the contracted value 50% (Fifty) shall be paid not less than 90 days before commencement of tour.</li>
</ul>


<strong>Cancellations : </strong>

<ul>
	<li>Travel dates may be changed up to 95 days prior to travel without penalty. An administration charge of 15% will be charged, if a confirmed booking is changed or transferred up to 95 days before commencement of the tour. After this time all changes will be treated as cancellation and will be subject to the charges mentioned below. Cancellation charges are calculated from the day, written acceptance of confirmation along with deposit is received by the &ldquo;Company&rdquo; and expressed herewith as a percentage of the total tour price including surcharge as follows: </li>
</ul>


<strong>Cancellation Charges: </strong>

<ul>
	<li>Days Prior to Arrival - 0- 60 Days: 100%</li>
	<li>60-90 Days: 60%</li>
	<li>91+ Days: 15% </li>
</ul>

<p> 

<ul>
	<li>All disputes subject to Delhi Courts only. </li>
</ul>

<p><strong>Please Note The Following: </strong>

<ul>
	<li>Tour cost includes presently prevailing State and Government taxes, applicable on accommodation and transportation. In case of any hike in taxes, surcharge will be applicable. </li>
	<li>Suggested hotels are subject to availability at the time of booking. In case the same is not available, then the best similar category will be provided </li>
	<li>Tour cost is not refundable for any cause, once the tour starts </li>
	<li>All tours subject to 100% advance payment minimum 30 days prior to start date. </li>
	<li>Tour guide reserves the rights to make changes detour or omit any place of visit if it becomes necessary due to bad weather, bad road, strike or shutdown and any security reason. # Tourist will carry their luggage at own risk and responsibility; C&rsquo; MORE Travel &amp; Tours or any of its associate agents, do not hold any responsibility for any loss of luggage during the tour.</li>
</ul>


<strong>Validity : </strong>

<ul>
	<li>01st October 2018 to 31st March 2019 However Rates are not valid between 20th December &amp; 06th January 2019</li>
</ul>								</div>
								</section>
														<section id="s9">
						<div class="data mb20px m_p25px large res_table">            
						<div class="mb7px"> 
						<p class="fw7 xxlarge mb10px dib">Price &amp; Rates</p>
						</div>				
				        <table class="mb15px bdrall bdreee w100 p10px20px formTable">
				        	<tr class="headVr b">
			                	<th class="p15px al">No of pax</th>
			                    <th class="p15px al">Age Limit</th>
			                    <th class="p15px al">Price per pax (Rs)</th>
			                </tr>

															<tr>
				            	<td class="p15px"><span class="fw6 tblTitle">No of pax </span> Adult</td>
				                <td class="p15px"><span class="fw6 tblTitle">Age Limit </span> Above 12 years</td>
				                <td class="p15px"><span class="fw6 tblTitle">Price per pax (Rs) </span> 
			                	<b>$</b>			                	<b>899</b> <small>/
			
			                		Adult			
			                				
			                		
			                	</small></td>
				            	</tr>
				            					         </table>
						</div>
						</section>
					 							<section id="s10">
						<div class="data mb20px m_p25px large">            
						<div class="mb7px"> 
						<p class="fw7 xxlarge mb10px dib">Packages by Theme</p>
						</div>
													<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.cmoretravels.in/golden-triangle-holidays-catid.htm" title="Golden Triangle Tour Packages">Golden Triangle Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.cmoretravels.in/heritage-holidays-catid.htm" title="Heritage Tour Packages">Heritage Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.cmoretravels.in/spa-wellness-holidays-catid.htm" title="Spa / Wellness Tour Packages">Spa / Wellness Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.cmoretravels.in/beach-islands-holidays-catid.htm" title="Beaches and Islands Tour Packages">Beaches and Islands Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.cmoretravels.in/family-holidays-catid.htm" title="Family Tour Packages">Family Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.cmoretravels.in/group-holidays-catid.htm" title="Group Tour Packages">Group Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.cmoretravels.in/luxury-holidays-catid.htm" title="Luxury Tour Packages">Luxury Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.cmoretravels.in/yoga-meditation-catid.htm" title="Yoga & Meditation Tour Packages">Yoga & Meditation Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.cmoretravels.in/religious-pilgrimage-holidays-catid.htm" title="Religious & Pilgrimage Tour Packages">Religious & Pilgrimage Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.cmoretravels.in/forts-palaces-holidays-catid.htm" title="Forts and Palaces Tour Packages">Forts and Palaces Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/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="https://www.cmoretravels.in/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="https://www.cmoretravels.in/cruise-holidays-catid.htm" title="Ship & Cruise Tour Packages">Ship & Cruise Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/bird-watching-holidays-catid.htm" title="Bird Watching Tour Packages">Bird Watching Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/food-drink-holidays-catid.htm" title="Food and Drink Tour Packages">Food and Drink Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/hill-station-holidays-catid.htm" title="Hill Stations & Valleys Tour Packages">Hill Stations & Valleys Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/honeymoon-holidays-catid.htm" title="Honeymoon Tour Packages">Honeymoon Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/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="https://www.cmoretravels.in/national-parks-holidays-catid.htm" title="Wildlife Sanctuaries & National Parks Tour Packages">Wildlife Sanctuaries & National Parks Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/lakes-rivers-holidays-catid.htm" title="Lakes & Rivers Tour Packages">Lakes & Rivers Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/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="https://www.cmoretravels.in/wildlife-nature-holidays-catid.htm" title="Wildlife Tour Packages">Wildlife Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/jungle-safari-holidays-catid.htm" title="Jungle Safari Tour Packages">Jungle Safari Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/festive-events-holidays-catid.htm" title="Festive & Events Tour Packages">Festive & Events Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/road-trip-holidays-catid.htm" title="Road Trip Tour Packages">Road Trip Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/shopping-holidays-catid.htm" title="Shopping Tour Packages">Shopping Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/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="https://www.cmoretravels.in/winter-holidays-catid.htm" title="Winter Tour Packages">Winter Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/house-boat-holidays-catid.htm" title="House Boat Tour Packages">House Boat Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/boating-holidays-catid.htm" title="Boating Tour Packages">Boating Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/jeep-safari-holidays-catid.htm" title="Jeep Safari Tour Packages">Jeep Safari Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/cycling-holidays-catid.htm" title="Cycling Tour Packages">Cycling Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/elephant-safari-holidays-catid.htm" title="Elephant Safari Tour Packages">Elephant Safari Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/art-galleries-holidays-catid.htm" title="Art Galleries Tour Packages">Art Galleries Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/museums-holidays-catid.htm" title="Museums Tour Packages">Museums Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/sightseeing-holidays-catid.htm" title="Sightseeing Tour Packages">Sightseeing Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.cmoretravels.in/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:;" >View More</a></span>
													</div>
						</section>
												
						<div class="ac mb10px">
						<form class="inquiry-form" name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.cmoretravels.in/enquiry-form-10028.htm">
						<input type="hidden" name="subject" value="Taj, Temple & Ganges Tour - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>							
						<input type="hidden" name="pkg_slno" value="105789"/>
						</form>
						<a href="javascript:;" class="submit-inquiry button p10px20px w150px fw6 large dib ttu ts0">Book Your Tour</a>
						</div>
											<div id="myModal" class="modal fade dn pf" role="dialog" style="z-index:9999;left:0;top:0%;width:100%;height:100%;background-color:rgba(0,0,0,0.6);overflow-x: hidden; overflow-y: auto;">
					    <!-- Modal content-->
					    <div style="max-width:380px;margin-top: 50px;min-height:400px;" class="modal-content data m0a p10px pr">
					      <div class="modal-header">
					        <a style="right:25px;top:25px;" class="pa b xxxlarge" data-dismiss="modal"><span class="xlarge">&times;</span></a>	        
					      </div>
					      <div class="modal-body">
					        <p>Loading...</p>
					      </div>
					      <div class="modal-footer">
					        
					      </div>
					    </div>
					</div>
					<script type="text/javascript">
						jQuery(document).ready(function(){
							jQuery(document).on("click", ".submit-inquiry" , function(e){e.stopPropagation()
								var form = jQuery(this).parent().find(".inquiry-form");
								if(form.length){
									jQuery.ajax({
										url: form.attr("action"),
										type: form.attr("method"),
										data:form.serialize(),
										crossDomain:true,
										success:function(res){
											jQuery("#myModal .modal-body").html(res);
										}
									});
								}
							});
							jQuery(document).on("click", "[data-dismiss=modal]", function(){
								jQuery("#myModal .modal-body").html("<p>Loading...</p>");
								jQuery("#myModal").hide();
							});
							jQuery(document).on("submit", "form[name=static_form]", function(e){				
								e.preventDefault();
								var isValidForm =static_inq_form_validate(jQuery(this).attr("form-id"));
								if(isValidForm == undefined){
									var form = jQuery(this);
									if(form.length){
										jQuery.ajax({
											url: form.attr("action"),
											type: form.attr("method"),
											data:form.serialize(),
											crossDomain:true,
											beforeSend:function(){
												jQuery("#myModal .modal-footer").html("");
											},
											success:function(res){
												jQuery("#myModal .modal-body").html(res);
												setTimeout(function(){
													jQuery("#myModal", document).hide();
													jQuery("#myModal .modal-body").html("<p>Loading...</p>");
													},2000)
											}
										});
									}
								}
							});
							var modal = jQuery("#myModal", document);
				
							jQuery(document).on("click", ".submit-inquiry" , function(){
							    modal.show();
							});
				
							window.onclick = function(event) {
							    if (jQuery(event.target) == modal) {
							        modal.css("display","none");
							    }
							}
						});
					</script>
									</div>
									<div class="col-3 thinColumn"><!--MIDDLE ROW1 COL-1 STARTS-->
					<div class="column_Box mc rghtFix">
					<div class="tcl bullet data divider enqForm stickyForm">
					<div class="h h2 ac xxlarge theme2 p10px" style="color:#fff;"><b class="plusMinus"></b>
					Fill Enquiry Form Below
					</div>
					<div class="showHide_rp mt7px p10px">
					<form name="package_form" method="post" action="//catalog.tourtravelworld.com/catalog-enquiry.php" onsubmit="return static_inq_form_validate(10029);">
					<div class="fo">
					<div class="mb15px">
					<input type="text" name="dynFrm_contact_person" id="dynFrm_contact_person_10029" placeholder="Your Full Name" />
					<span class="red small"></span>
					</div>
					<div class="fl w100 mb15px">
					<textarea name="dynFrm_details_2" id="dynFrm_details_2_10029">I am interested in Taj, Temple & Ganges Tour. Please get in contact with me.</textarea>
					<span class="fl red small"></span>
					</div>
					<div class="fl w100 mb15px df-dt">
					<div class="df-dtc w50 pr5px dateOpt pr"><input type="text" name="dynFrm_arrival_date" id="dynFrm_arrival_date_10029" class="dynFrm_arrival_date" style="padding-left:30px;" placeholder=" Departure Date" /><span class="fl red small"></span></div>
					<div class="df-dtc pl5px"><input type="text" name="dynFrm_duration" id="dynFrm_duration_10029" placeholder="Number of Days" /><span class="fl red small"></span></div>
					</div>  
					<div class="mb15px">
					<input type="text" name="dynFrm_email_id" id="dynFrm_email_id_10029" placeholder="Email" />
					<span class="red small"></span>
					</div> 
					<div class="mb20px fl w100">
					<div class="w60px pr fl ofh">
					<div id="isdpackCode" class="isdCode pr0px">+91</div>
					<select class="contSelect" name="dynFrm_country" id="dynFrm_country" onChange="document.getElementById('phone_package_isd').value=this.value.substr(3, 4); document.getElementById('isdpackCode').innerHTML=this.value.substr(3, 4);">
					
											
						<option value="AF^+93" >Afghanistan +93</option>
					
												
						<option value="CF^+236" >African Republic +236</option>
					
												
						<option value="AL^+355" >Albania +355</option>
					
												
						<option value="DZ^+213" >Algeria +213</option>
					
												
						<option value="AS^+0" >American Samoa +0</option>
					
												
						<option value="AD^+376" >Andorra +376</option>
					
												
						<option value="AO^+244" >Angola +244</option>
					
												
						<option value="AI^+264" >Anguilla +264</option>
					
												
						<option value="AG^+268" >Antigua and Barbuda +268</option>
					
												
						<option value="AR^+54" >Argentina +54</option>
					
												
						<option value="AM^+374" >Armenia +374</option>
					
												
						<option value="AW^+297" >Aruba +297</option>
					
												
						<option value="AU^+61" >Australia +61</option>
					
												
						<option value="AT^+43" >Austria +43</option>
					
												
						<option value="AZ^+994" >Azerbaijan +994</option>
					
												
						<option value="BS^+242" >Bahamas +242</option>
					
												
						<option value="BH^+973" >Bahrain +973</option>
					
												
						<option value="BD^+880" >Bangladesh +880</option>
					
												
						<option value="BB^+246" >Barbados +246</option>
					
												
						<option value="BY^+375" >Belarus +375</option>
					
												
						<option value="BE^+32" >Belgium +32</option>
					
												
						<option value="BZ^+501" >Belize +501</option>
					
												
						<option value="BJ^+229" >Benin +229</option>
					
												
						<option value="BM^+441" >Bermuda +441</option>
					
												
						<option value="BT^+975" >Bhutan +975</option>
					
												
						<option value="BO^+591" >Bolivia +591</option>
					
												
						<option value="BA^+387" >Bosnia and Herzegovina +387</option>
					
												
						<option value="BW^+267" >Botswana +267</option>
					
												
						<option value="BV^+47" >Bouvet +47</option>
					
												
						<option value="BR^+55" >Brazil +55</option>
					
												
						<option value="BN^+673" >Brunei +673</option>
					
												
						<option value="BG^+359" >Bulgaria +359</option>
					
												
						<option value="BF^+226" >Burkina +226</option>
					
												
						<option value="BF^+0" >Burkina Faso +0</option>
					
												
						<option value="BI^+257" >Burundi +257</option>
					
												
						<option value="KH^+855" >Cambodia +855</option>
					
												
						<option value="CM^+237" >Cameroon +237</option>
					
												
						<option value="CA^+1" >Canada +1</option>
					
												
						<option value="CV^+238" >Cape Verde +238</option>
					
												
						<option value="KY^+345" >Cayman Islands +345</option>
					
												
						<option value="236^+236" >Central African Republic +236</option>
					
												
						<option value="TD^+235" >Chad +235</option>
					
												
						<option value="IO^+246" >Chagos +246</option>
					
												
						<option value="CL^+56" >Chile +56</option>
					
												
						<option value="CN^+86" >China +86</option>
					
												
						<option value="CX^+61" >Christmas Island +61</option>
					
												
						<option value="CC^+61" >Cocos +61</option>
					
												
						<option value="CO^+57" >Colombia +57</option>
					
												
						<option value="KM^+269" >Comoros +269</option>
					
												
						<option value="CG^+242" >Congo +242</option>
					
												
						<option value="CK^+682" >Cook Islands +682</option>
					
												
						<option value="RCI^+506" >Costa Rica +506</option>
					
												
						<option value="HR^+385" >Croatia +385</option>
					
												
						<option value="CY^+357" >Cyprus +357</option>
					
												
						<option value="CZ^+420" >Czech Republic +420</option>
					
												
						<option value="DK^+45" >Denmark +45</option>
					
												
						<option value="DJ^+253" >Djibouti +253</option>
					
												
						<option value="DM^+767" >Dominica +767</option>
					
												
						<option value="DO^+809" >Dominican Republic +809</option>
					
												
						<option value="EOA^+257" >East Africa +257</option>
					
												
						<option value="TP^+670" >East Timor +670</option>
					
												
						<option value="EC^+593" >Ecuador +593</option>
					
												
						<option value="EG^+20" >Egypt +20</option>
					
												
						<option value="SV^+503" >El Salvador +503</option>
					
												
						<option value="GQ^+0" >Equatorial Guinea +0</option>
					
												
						<option value="ER^+291" >Eritrea +291</option>
					
												
						<option value="EE^+372" >Estonia +372</option>
					
												
						<option value="ET^+251" >Ethiopia +251</option>
					
												
						<option value="FO^+298" >Faroe +298</option>
					
												
						<option value="FM^+691" >Federated States of Micronesia +691</option>
					
												
						<option value="FJ^+679" >Fiji +679</option>
					
												
						<option value="FI^+358" >Finland +358</option>
					
												
						<option value="FR^+33" >France +33</option>
					
												
						<option value="FX^+590" >France, Metropolitan +590</option>
					
												
						<option value="GF^+594" >French Guiana +594</option>
					
												
						<option value="FP^+689" >French Polynesia +689</option>
					
												
						<option value="TF^+590" >French Southern Territories +590</option>
					
												
						<option value="GA^+241" >Gabon +241</option>
					
												
						<option value="GM^+220" >Gambia +220</option>
					
												
						<option value="GE^+995" >Georgia +995</option>
					
												
						<option value="DE^+49" >Germany +49</option>
					
												
						<option value="GH^+233" >Ghana +233</option>
					
												
						<option value="GI^+350" >Gibraltar +350</option>
					
												
						<option value="GR^+30" >Greece +30</option>
					
												
						<option value="GL^+299" >Greenland +299</option>
					
												
						<option value="GD^+809" >Grenada +809</option>
					
												
						<option value="Gre^+473" >Grenada +473</option>
					
												
						<option value="GP^+590" >Guadeloupe +590</option>
					
												
						<option value="GU^+1" >Guam +1</option>
					
												
						<option value="GT^+502" >Guatemala +502</option>
					
												
						<option value="GN^+224" >Guinea +224</option>
					
												
						<option value="GW^+245" >Guinea-bissau +245</option>
					
												
						<option value="GY^+592" >Guyana +592</option>
					
												
						<option value="HT^+509" >Haiti +509</option>
					
												
						<option value="HM^+61" >Heard and Mc Donald Islands +61</option>
					
												
						<option value="HN^+504" >Honduras +504</option>
					
												
						<option value="HU^+36" >Hungary +36</option>
					
												
						<option value="IS^+354" >Iceland +354</option>
					
												
						<option value="IN^+91"  selected="selected" >India +91</option>
					
												
						<option value="ID^+62" >Indonesia +62</option>
					
												
						<option value="IQ^+964" >Iraq +964</option>
					
												
						<option value="IE^+353" >Ireland +353</option>
					
												
						<option value="Isi^Isiolo" >Isiolo Isiolo</option>
					
												
						<option value="IL^+972" >Israel +972</option>
					
												
						<option value="IT^+39" >Italy +39</option>
					
												
						<option value="CI^+225" >Ivory Coast +225</option>
					
												
						<option value="JM^+876" >Jamaica +876</option>
					
												
						<option value="JP^+81" >Japan +81</option>
					
												
						<option value="JO^+962" >Jordan +962</option>
					
												
						<option value="KZ^+7" >Kazakhstan +7</option>
					
												
						<option value="KE^+254" >Kenya +254</option>
					
												
						<option value="KI^+686" >Kiribati +686</option>
					
												
						<option value="KW^+965" >Kuwait +965</option>
					
												
						<option value="KG^+996" >Kyrgyzstan +996</option>
					
												
						<option value="LA^+856" >Lao People's Democratic Republic +856</option>
					
												
						<option value="LA^+856" >Laos +856</option>
					
												
						<option value="LV^+371" >Latvia +371</option>
					
												
						<option value="LB^+961" >Lebanon +961</option>
					
												
						<option value="LS^+266" >Lesotho +266</option>
					
												
						<option value="LR^+231" >Liberia +231</option>
					
												
						<option value="LY^+218" >Libya +218</option>
					
												
						<option value="LI^+423" >Liechtenstein +423</option>
					
												
						<option value="LT^+370" >Lithuania +370</option>
					
												
						<option value="LU^+352" >Luxembourg +352</option>
					
												
						<option value="MO^+853" >Macau +853</option>
					
												
						<option value="MK^+389" >Macedonia +389</option>
					
												
						<option value="MG^+261" >Madagascar +261</option>
					
												
						<option value="MW^+265" >Malawi +265</option>
					
												
						<option value="MY^+60" >Malaysia +60</option>
					
												
						<option value="MV^+960" >Maldives +960</option>
					
												
						<option value="ML^+223" >Mali +223</option>
					
												
						<option value="MT^+356" >Malta +356</option>
					
												
						<option value="FK^+500" >Malvinas +500</option>
					
												
						<option value="MH^+692" >Marshall Islands +692</option>
					
												
						<option value="MQ^+596" >Martinique +596</option>
					
												
						<option value="MR^+222" >Mauritania +222</option>
					
												
						<option value="MU^+230" >Mauritius +230</option>
					
												
						<option value="YT^+269" >Mayotte +269</option>
					
												
						<option value="MX^+52" >Mexico +52</option>
					
												
						<option value="MD^+0" >Moldova +0</option>
					
												
						<option value="MD^+373" >Moldova (Republic of Moldova) +373</option>
					
												
						<option value="MC^+377" >Monaco +377</option>
					
												
						<option value="MN^+976" >Mongolia +976</option>
					
												
						<option value="ME^+381" >Montenegro +381</option>
					
												
						<option value="MS^+664" >Montserrat +664</option>
					
												
						<option value="MA^+212" >Morocco +212</option>
					
												
						<option value="MZ^+258" >Mozambique +258</option>
					
												
						<option value="MM^+95" >Myanmar +95</option>
					
												
						<option value="NA^+264" >Namibia +264</option>
					
												
						<option value="NR^+674" >Nauru +674</option>
					
												
						<option value="NP^+977" >Nepal +977</option>
					
												
						<option value="NL^+31" >Netherlands +31</option>
					
												
						<option value="AN^+599" >Netherlands Antilles +599</option>
					
												
						<option value="NC^+687" >New Caledonia +687</option>
					
												
						<option value="PG^+675" >New Guinea +675</option>
					
												
						<option value="NZ^+64" >New Zealand +64</option>
					
												
						<option value="NI^+505" >Nicaragua +505</option>
					
												
						<option value="NE^+227" >Niger +227</option>
					
												
						<option value="NG^+234" >Nigeria +234</option>
					
												
						<option value="NU^+683" >Niue +683</option>
					
												
						<option value="NF^+672" >Norfolk Island +672</option>
					
												
						<option value="MP^+670" >Northern Mariana Islands +670</option>
					
												
						<option value="NO^+47" >Norway +47</option>
					
												
						<option value="OM^+968" >Oman +968</option>
					
												
						<option value="PK^+92" >Pakistan +92</option>
					
												
						<option value="PW^+680" >Palau +680</option>
					
												
						<option value="PA^+507" >Panama +507</option>
					
												
						<option value="PG^+0" >Papua New Guinea +0</option>
					
												
						<option value="PY^+595" >Paraguay +595</option>
					
												
						<option value="PE^+51" >Peru +51</option>
					
												
						<option value="PH^+63" >Philippines +63</option>
					
												
						<option value="PN^+872" >Pitcairn +872</option>
					
												
						<option value="PL^+48" >Poland +48</option>
					
												
						<option value="PF^+689" >Polynesia +689</option>
					
												
						<option value="PT^+351" >Portugal +351</option>
					
												
						<option value="PR^+1-787" >Puerto Rico +1-787</option>
					
												
						<option value="QA^+974" >Qatar +974</option>
					
												
						<option value="RE^+262" >Reunion +262</option>
					
												
						<option value="RO^+40" >Romania +40</option>
					
												
						<option value="RU^+7" >Russia +7</option>
					
												
						<option value="RW^+250" >Rwanda +250</option>
					
												
						<option value="KN^+869" >Saint Kitts and Nevis +869</option>
					
												
						<option value="LC^+758" >Saint Lucia +758</option>
					
												
						<option value="VC^+784" >Saint Vincent and the Grenadines +784</option>
					
												
						<option value="WS^+685" >Samoa +685</option>
					
												
						<option value="SM^+378" >San Marino +378</option>
					
												
						<option value="ST^+239" >Sao Tome And Principe +239</option>
					
												
						<option value="SA^+966" >Saudi Arabia +966</option>
					
												
						<option value="SN^+221" >Senegal +221</option>
					
												
						<option value="RS^+381" >Serbia +381</option>
					
												
						<option value="SC^+248" >Seychelles +248</option>
					
												
						<option value="SL^+232" >Sierra Leone +232</option>
					
												
						<option value="SG^+65" >Singapore +65</option>
					
												
						<option value="SK^+421" >Slovakia +421</option>
					
												
						<option value="SI^+386" >Slovenia +386</option>
					
												
						<option value="SB^+677" >Solomon Islands +677</option>
					
												
						<option value="SO^+252" >Somalia +252</option>
					
												
						<option value="ZA^+27" >South Africa +27</option>
					
												
						<option value="GS^+44" >South Georgia and the South Sandwich Islands +44</option>
					
												
						<option value="KR^+82" >South Korea +82</option>
					
												
						<option value="ES^+34" >Spain +34</option>
					
												
						<option value="LK^+94" >Sri Lanka +94</option>
					
												
						<option value="SH^+290" >St. Helena +290</option>
					
												
						<option value="PM^+508" >St. Pierre and Miquelon +508</option>
					
												
						<option value="SD^+249" >Sudan +249</option>
					
												
						<option value="SR^+597" >Suriname +597</option>
					
												
						<option value="SJ^+47" >Svalbard and Jan Mayen Islands +47</option>
					
												
						<option value="SZ^+268" >Swaziland +268</option>
					
												
						<option value="SE^+46" >Sweden +46</option>
					
												
						<option value="CH^+41" >Switzerland +41</option>
					
												
						<option value="TW^+886" >Taiwan +886</option>
					
												
						<option value="TJ^+992" >Tajikistan +992</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="Taj, Temple & Ganges Tour - Tour Package"/>
					<input type="hidden" name="allocate_type" value="tour"/>
					<input type="hidden" name="pkg_slno" value="105789"/>
					<input type="hidden" name="current_url" value="https://www.cmoretravels.in/tour-packages/taj-temple-ganges-tour.htm">
				  	<input type="hidden" name="web_address" value="https://www.cmoretravels.in">
				  	<input type="hidden" name="inq_thanks_msg" value="Thank you for inquiry.<br /><br />We have received your request. Our Sales Team will soon get in touch with you.<br /><br /><br />">
					<input type="hidden" name="inq_thanks_title" value="Enquiry">
				  	<input type="hidden" name="redirected_url" value="https://www.cmoretravels.in/thanks.htm">
					<input type="hidden" name="catalog_mi" value="401707">
				  	<input type="hidden" name="id" value="static_form">
				  	<input type="hidden" name="form_id" value="10029">
					</form>
					</div>
					</div>					
					</div>
					</div>
					<style>
					.ui-datepicker-trigger {
						vertical-align : middle;
					}
					</style>
					<script>
					jQuery('.dynFrm_arrival_date').datepicker({minDate: 0,
					buttonImage: '//catalog.wlimg.com/jquery-date-picker/calbtn.gif',
					buttonText: 'Click to view calendar',
				    buttonImageOnly: true,
				    showOn: 'button',
				    changeMonth: true,
				    changeYear: true,
				    onClose: function(dateText, inst) {
				        var endDateTextBox = jQuery('.dynFrm_departure_date');
				        if (endDateTextBox.val() != '') {
				            var testStartDate = new Date(dateText);
				            var testEndDate = new Date(endDateTextBox.val());
				            if (testStartDate > testEndDate)
				                endDateTextBox.val(dateText);
				        }
				    }, 
					    onSelect: function (selectedDateTime){
					        var start = jQuery(this).datepicker('getDate');
					        jQuery('.dynFrm_departure_date').datepicker('option', 'minDate', new Date(start.getTime()));
					        jQuery('#dynFrm_departure_date').datepicker('option', 'minDate', new Date(start.getTime()));
					    }    
					});
					jQuery('.dynFrm_departure_date').datepicker({
					minDate: 0,
					buttonImage: '//catalog.wlimg.com/jquery-date-picker/calbtn.gif',
					buttonText: 'Click to view calendar',
				    buttonImageOnly: true,
				    showOn: 'button',
				    changeMonth: true,
				    changeYear: true,
				    onClose: function(dateText, inst) {
				        var startDateTextBox = jQuery('.dynFrm_arrival_date');
				        if (startDateTextBox.val() != '') {
				            var testStartDate = new Date(startDateTextBox.val());
				            var testEndDate = new Date(dateText);
				            if (testStartDate > testEndDate)
				                startDateTextBox.val(dateText);
				        }
				    },
				    onSelect: function (selectedDateTime){
				        var end = jQuery(this).datepicker('getDate');
				        jQuery('.dynFrm_arrival_date').datepicker('option', 'maxDate', new Date(end.getTime()) );
				        jQuery('#dynFrm_arrival_date').datepicker('option', 'maxDate', new Date(end.getTime()) );
				    }
					});
					</script>
					<script>
					jQuery(document).ready(function(){
					var sticky = jQuery('.stickyForm').offset().top;
					jQuery(window).scroll(function(){      
					 if(jQuery(window).scrollTop() > sticky){
					  jQuery('.stickyForm').css('position','fixed');
					  jQuery('.stickyForm').css('top','75px'); 
					 }
					 else if (jQuery(window).scrollTop() <= sticky) {
					  jQuery('.stickyForm').css('position','');
					  jQuery('.stickyForm').css('top','');
					 }  
					if (jQuery('.stickyForm').offset().top + jQuery(".stickyForm").height() > jQuery(".rel-prop").offset().top) {
					  jQuery('.stickyForm').css('top',-(jQuery(".stickyForm").offset().top + jQuery(".stickyForm").height() - jQuery(".rel-prop").offset().top));
					}
					});
					});
					</script>
					<script>
					jQuery(document).ready(function(e){
					if (jQuery(window).width() < 992) {
					jQuery(".rghtFix .enqForm .h").on("click", function(){
					  jQuery(this).find('.plusMinus').toggleClass('act').parent().next('.showHide_rp').slideToggle('slow');
					});  
					jQuery(".rghtFix .enqForm .plusMinus").on("click", function(e){
					e.stopPropagation(); 
					});
					}
					});  
					</script>
					</div>
					</div>
									
				
				</div>
				
										<section class="pt30px pb10px relTour-pkg rel-prop">
						<div class="wrap">      
						<div class="fo">
						<div class="ac mb7px"><div><h2 class="hd_NT">Similar Tour Packages for New Delhi, Jaipur, Agra, Jhansi, Varanasi, Khajuraho</h2></div></div>
						<div class="ic" id="1102_3-1">
						<div class="slider">
						<ul class="bxslider987">
											
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.cmoretravels.in/tour-packages/rajasthan-shekhawati-region-tour.htm'">
															<div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px"><img src="https://static.tourtravelworld.com/images/tour-package-no-image.gif"  height=""  width=""    alt="Rajasthan - Shekhawati Region Tour" title="Rajasthan - Shekhawati Region Tour"  class="bdr p1px" loading="lazy" ></div></div>
								<div class="absViewBtn"><a href="https://www.cmoretravels.in/tour-packages/rajasthan-shekhawati-region-tour.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								16 Nights / 17 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.cmoretravels.in/tour-packages/rajasthan-shekhawati-region-tour.htm" title="Rajasthan - Shekhawati Region Tour"><h3>Rajasthan - Shekhawati Region Tour</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.cmoretravels.in/tour-packages/camel-safariin-rajasthan-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_14/401707/131721.jpg"  height=""  width=""    alt="Camel Safari in Rajasthan Tour" title="Camel Safari in Rajasthan Tour"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.cmoretravels.in/tour-packages/camel-safariin-rajasthan-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="https://www.cmoretravels.in/tour-packages/camel-safariin-rajasthan-tour.htm" title="Camel Safari in Rajasthan Tour"><h3>Camel Safari In Rajasthan Tour</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.cmoretravels.in/tour-packages/adventure-india-wildlife-escapades.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_14/401707/224368.jpg"  height=""  width=""    alt="Adventure India - Wildlife Escapades" title="Adventure India - Wildlife Escapades"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.cmoretravels.in/tour-packages/adventure-india-wildlife-escapades.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="https://www.cmoretravels.in/tour-packages/adventure-india-wildlife-escapades.htm" title="Adventure India - Wildlife Escapades"><h3>Adventure India - Wildlife Escapades</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.cmoretravels.in/tour-packages/the-golden-triangle-north-india.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_14/401707/133147.jpg"  height=""  width=""    alt="The Golden Triangle - North India Tour" title="The Golden Triangle - North India Tour"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.cmoretravels.in/tour-packages/the-golden-triangle-north-india.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								6 Nights / 7 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.cmoretravels.in/tour-packages/the-golden-triangle-north-india.htm" title="The Golden Triangle - North India Tour"><h3>The Golden Triangle - North India Tour</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.cmoretravels.in/tour-packages/rajasthan-landof-kings-queens-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_14/401707/225014.jpg"  height=""  width=""    alt="Rajasthan - Land of Kings & Queens Tour" title="Rajasthan - Land of Kings & Queens Tour"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.cmoretravels.in/tour-packages/rajasthan-landof-kings-queens-tour.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								13 Nights / 14 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.cmoretravels.in/tour-packages/rajasthan-landof-kings-queens-tour.htm" title="Rajasthan - Land of Kings & Queens Tour"><h3>Rajasthan - Land Of Kings & Queens Tour</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.cmoretravels.in/tour-packages/splendorsof-rajasthan-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_14/401707/131612.jpg"  height=""  width=""    alt="Taj Mahal Agra" title="Taj Mahal Agra"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.cmoretravels.in/tour-packages/splendorsof-rajasthan-tour.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								22 Nights / 23 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.cmoretravels.in/tour-packages/splendorsof-rajasthan-tour.htm" title="Splendors of Rajasthan Tour"><h3>Splendors Of Rajasthan Tour</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.cmoretravels.in/tour-packages/pushkar-fair-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_14/401707/131611.jpg"  height=""  width=""    alt="Pushkar Fair Tour" title="Pushkar Fair Tour"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.cmoretravels.in/tour-packages/pushkar-fair-tour.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="https://www.cmoretravels.in/tour-packages/pushkar-fair-tour.htm" title="Pushkar Fair Tour"><h3>Pushkar Fair Tour</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.cmoretravels.in/tour-packages/ladakh-hemis-festival.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_14/401707/133163.jpg"  height=""  width=""    alt="Hemis -Mask Dance" title="Hemis -Mask Dance"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.cmoretravels.in/tour-packages/ladakh-hemis-festival.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="https://www.cmoretravels.in/tour-packages/ladakh-hemis-festival.htm" title="Ladakh - Hemis Festival Package"><h3>Ladakh - Hemis Festival Package</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.cmoretravels.in/tour-packages/long-weekend-breaks-the-golden-triangle-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_14/401707/238412.jpg"  height=""  width=""    alt="Long Weekend Breaks - the Golden Triangle Tour" title="Long Weekend Breaks - the Golden Triangle Tour"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.cmoretravels.in/tour-packages/long-weekend-breaks-the-golden-triangle-tour.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="https://www.cmoretravels.in/tour-packages/long-weekend-breaks-the-golden-triangle-tour.htm" title="Long Weekend Breaks - the Golden Triangle Tour"><h3>Long Weekend Breaks - The Golden Triangle Tour</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.cmoretravels.in/tour-packages/bestof-north-west-india-with-nepal-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_14/401707/248767.jpg"  height=""  width=""    alt="Mumbai" title="Mumbai"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.cmoretravels.in/tour-packages/bestof-north-west-india-with-nepal-tour.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								17 Nights / 18 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.cmoretravels.in/tour-packages/bestof-north-west-india-with-nepal-tour.htm" title="Best of North & West India with Nepal Tour"><h3>Best Of North & West India With Nepal Tour</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.cmoretravels.in/tour-packages/footstepsof-buddha-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_14/401707/248799.jpg"  height=""  width=""    alt="Footsteps of Buddha Tour" title="Footsteps of Buddha Tour"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.cmoretravels.in/tour-packages/footstepsof-buddha-tour.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="https://www.cmoretravels.in/tour-packages/footstepsof-buddha-tour.htm" title="Footsteps of Buddha Tour"><h3>Footsteps Of Buddha Tour</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">
					<div class="wrap">
					<div class="fo">     	
					<div class="ac mb7px"><div><h2 class="hd_NT">Explore Tour Packages by Destination</h2></div></div>     	
					<div class="ic" id="1102_3-1">
					<div class="slider">
					<ul class="bxslider988">								
					
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.cmoretravels.in/packages-in-new-delhi.htm" title="Packages in New Delhi" >
						<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="https://www.cmoretravels.in/packages-in-new-delhi.htm" title="Packages in New Delhi">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="https://www.cmoretravels.in/packages-in-jaipur.htm" title="Packages in Jaipur" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10096-classified.jpg"  height=""  width=""    alt="Jaipur" title="Jaipur" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.cmoretravels.in/packages-in-jaipur.htm" title="Packages in Jaipur">Jaipur Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.cmoretravels.in/packages-in-agra.htm" title="Packages in Agra" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10119-classified.jpg"  height=""  width=""    alt="Agra" title="Agra" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.cmoretravels.in/packages-in-agra.htm" title="Packages in Agra">Agra Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.cmoretravels.in/packages-in-jodhpur.htm" title="Packages in Jodhpur" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10098-classified.jpg"  height=""  width=""    alt="Jodhpur" title="Jodhpur" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.cmoretravels.in/packages-in-jodhpur.htm" title="Packages in Jodhpur">Jodhpur Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.cmoretravels.in/packages-in-ranakpur.htm" title="Packages in Ranakpur" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10539-classified.jpg"  height=""  width=""    alt="Ranakpur" title="Ranakpur" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.cmoretravels.in/packages-in-ranakpur.htm" title="Packages in Ranakpur">Ranakpur Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.cmoretravels.in/packages-in-jaisalmer.htm" title="Packages in Jaisalmer" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10097-classified.jpg"  height=""  width=""    alt="Jaisalmer" title="Jaisalmer" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.cmoretravels.in/packages-in-jaisalmer.htm" title="Packages in Jaisalmer">Jaisalmer Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.cmoretravels.in/packages-in-ranthambore.htm" title="Packages in Ranthambore" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10112-classified.jpg"  height=""  width=""    alt="Ranthambore" title="Ranthambore" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.cmoretravels.in/packages-in-ranthambore.htm" title="Packages in Ranthambore">Ranthambore Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.cmoretravels.in/packages-in-udaipur.htm" title="Packages in Udaipur" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10117-classified.jpg"  height=""  width=""    alt="Udaipur" title="Udaipur" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.cmoretravels.in/packages-in-udaipur.htm" title="Packages in Udaipur">Udaipur Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.cmoretravels.in/packages-in-varanasi.htm" title="Packages in Varanasi" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10150-classified.jpg"  height=""  width=""    alt="Varanasi" title="Varanasi" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.cmoretravels.in/packages-in-varanasi.htm" title="Packages in Varanasi">Varanasi Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.cmoretravels.in/packages-in-sawai-madhopur.htm" title="Packages in Sawai Madhopur" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10115-classified.jpg"  height=""  width=""    alt="Sawai Madhopur" title="Sawai Madhopur" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.cmoretravels.in/packages-in-sawai-madhopur.htm" title="Packages in Sawai Madhopur">Sawai Madhopur Tours</a></div>
						</div> 
						</li>
						
						<li>
						<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
						<a href="https://www.cmoretravels.in/packages-in-mumbai.htm" title="Packages in Mumbai" >
						<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="https://www.cmoretravels.in/packages-in-mumbai.htm" title="Packages in Mumbai">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="https://www.cmoretravels.in/packages-in-khajuraho.htm" title="Packages in Khajuraho" >
						<img src="https://dynamic.tourtravelworld.com/zsc-header/10323-classified.jpg"  height=""  width=""    alt="Khajuraho" title="Khajuraho" ></a>
						</div></div>
						<div class="h xlarge fw6 lh15em"><a href="https://www.cmoretravels.in/packages-in-khajuraho.htm" title="Packages in Khajuraho">Khajuraho Tours</a></div>
						</div> 
						</li>
											</ul>
					</div>
					</div>
					 
							<script>
							$(document).ready(function(){			
							$('.bxslider988').bxSlider({
							mode:'horizontal',				
							slideWidth: 214,maxSlides: 10,slideMargin:12,auto: true, 
							autoDirection:'next',
							moveSlides: 1,
							pause:2000,
							pager:false,
							pagerType:'full',
							autoControls: false, 
							controls:true, 
							autoHover:true,				
							speed:1000
							});
							});
							</script>
												
					</div>
					</div>
					</section>
									
				</div>
				</section>
				
				<script>
					window.addEventListener("DOMContentLoaded", function(){
						jQuery(document).on("click", ".showallspan", function(){
							if(jQuery(this).attr("data-target") === 'show'){
								jQuery(this).text("View Less");
								jQuery(this).attr("data-target", "hide");
								jQuery(this).closest("div").find(".spanlist").removeClass("dn");
							}else{
								jQuery(this).text("View More");
								jQuery(this).attr("data-target", "show");
								jQuery(this).closest("div").find(".spanlist").addClass("dn");
							}
						});
					});
				</script>
				";i:1;s:65:"Book Taj, Temple & Ganges Tour - 9 Nights / 10 Days Tour Packages";i:2;s:376:"book taj, temple & ganges tour - 9 nights / 10 days tour packages, adventure tour packages, new delhi, jaipur, agra, jhansi, khajuraho, varanasi, vishwanath temple, khajuraho, jaigarh fort, hawa mahal, taj mahal, kashi vishwanath temple, buland darwaza, fatehpur sikri, qutab minar, amber fort, city palace, india gate, lotus temple, jantar mantar, jantar mantar tour packages";i:3;s:414:"C More Travel & Tours offers Taj, Temple & Ganges Tour - 9 Nights / 10 Days tour package, budget Adventure tour packages for New Delhi, Jaipur, Agra, Jhansi, Khajuraho, Varanasi, Vishwanath Temple, Khajuraho, Jaigarh Fort, Hawa Mahal, Taj Mahal, Kashi Vishwanath Temple, Buland Darwaza, Fatehpur Sikri, Qutab Minar, Amber Fort, City Palace, India Gate, Lotus Temple, Jantar Mantar, Jantar Mantar at exciting price.";i:4;s:1825:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "New Delhi, Jaipur, Agra, Jhansi, Khajuraho, Varanasi, Vishwanath Temple, Khajuraho, Jaigarh Fort, Hawa Mahal, Taj Mahal, Kashi Vishwanath Temple, Buland Darwaza, Fatehpur Sikri, Qutab Minar, Amber Fort, City Palace, India Gate, Lotus Temple, Jantar Mantar, Jantar Mantar"        
		                 },
		      "description": "Classical India Tour is one of the most sought after programs for any tourist visiting India. Classical India tour lets you catch a glimpse of immensely beautiful destinations of north India. Be it the beautiful architectural city of Jaipur built of Red sandstone or one of the wonders of the world - the Taj Mahal either the visit to the temple of Kamasutra - Khajuraho or the boat ride on the Ganges river in the ancient city of Varanasi when the dawn hovers, name one beautifully exotic and spectacular destination, and north India never fails to surprise you with what it has store in for you. Spread over the span of eight days this tour lets you surrender in the tranquility of north India. Pack your bags and this tour would be the most cherished travel experience.10% DISCOUNT on published price, in case tour is booked & paid for 90 days prior to tour arrival date subject to minimum 2 persons travelling together.Breakfast on day of arrival
Meals where not mentioned
Medical & personal expenses like beverages
Tips and gratitude’s, telecommunication charges
Wi-Fi service
Laundry and what so ever not mentioned under “cost Includes1-1031-3",
		      "name": "Taj, Temple & Ganges Tour",
		      "telephone": "+91-9810398511"
		    }
		    </script>
			";i:5;N;i:6;s:73:"https://ttw.wlimg.com/package-images/photo-small/dir_14/401707/176013.jpg";}