a:7:{i:0;s:95923:"				<section id="middle" class="propDtls ttwBtmFtSpace">
				<div class="wrap thinFormat " id="bodyFormatNT">
									<div class="ar small fo"><a href="https://www.shreeganeshaholidays.com/" title="Home">Home</a>
					
											<b class="ffv p2px">&rsaquo;</b> <a href="https://www.shreeganeshaholidays.com/packages.htm" title="Packages">Packages</a>  			
											
					<b class="ffv p2px">&rsaquo;</b> <span class="alpha75">Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru</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_2/33682/311989.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311989.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311989.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311981.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311981.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311981.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311994.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311994.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311994.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311995.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311995.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311995.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311996.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311996.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311996.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311997.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311997.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311997.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311998.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311998.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311998.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311999.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311999.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311999.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/312000.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/312000.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/312000.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/312001.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/312001.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/312001.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/312002.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/312002.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/312002.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311993.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311993.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311993.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311992.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311992.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311992.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311982.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311982.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311982.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311983.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311983.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311983.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311984.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311984.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311984.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311985.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311985.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311985.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311986.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311986.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311986.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311987.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311987.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311987.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311988.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311988.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311988.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311990.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311990.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311990.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311991.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/311991.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311991.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/312003.jpg"><div class="imgWidth" style="background-image: url(https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/312003.jpg);background-size:cover;background-position:center;"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/312003.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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_2/33682/311989.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="1"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311981.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="2"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311994.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="3"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311995.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="4"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311996.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="5"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311997.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="6"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311998.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="7"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311999.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="8"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/312000.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="9"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/312001.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="10"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/312002.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="11"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311993.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="12"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311992.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="13"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311982.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="14"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311983.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="15"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311984.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="16"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311985.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="17"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311986.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="18"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311987.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="19"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311988.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="20"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311990.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="21"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311991.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></a></li>
																		<li data-slideIndex="22"><a href=""><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/312003.jpg"  height="150"  width="150"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" ></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>Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru</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.shreeganeshaholidays.com/tour-packages/bestof-south-india-pilgrimage-holidays-tour-packages-from-bengaluru.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.shreeganeshaholidays.com/tour-packages/bestof-south-india-pilgrimage-holidays-tour-packages-from-bengaluru.htm" class="instagram" title="Instagram"><i class="fa fa-instagram"></i></a></li>
					<li><a target="_blank" href="https://wa.me/?text=https://www.shreeganeshaholidays.com/tour-packages/bestof-south-india-pilgrimage-holidays-tour-packages-from-bengaluru.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=Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru&url=https://www.shreeganeshaholidays.com/tour-packages/bestof-south-india-pilgrimage-holidays-tour-packages-from-bengaluru.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.shreeganeshaholidays.com/tour-packages/bestof-south-india-pilgrimage-holidays-tour-packages-from-bengaluru.htm&title=Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" 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.shreeganeshaholidays.com/tour-packages/bestof-south-india-pilgrimage-holidays-tour-packages-from-bengaluru.htm&description=Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" class="pinterest" title="Pinterest"><i class="fa fa-pinterest-square"></i></a></li>
					<li><a href="javascript:;" title="Copy Link" class="copy" onclick="copyURL()"><i class="fa fa-clone"></i></a></li>
					</ul>
					</div>
					</div>
					<script>
					$(document).ready(function(){
					$('.ShareDropdown span').click(function(){
					 $('.ShareDropdown').toggleClass("active");
					}); 
					});
					</script>
					<script>
					  function copyURL() {
					    const url = window.location.href;
						const textarea = document.createElement("textarea");
						textarea.value = url;
						textarea.style.position = "fixed";
						document.body.appendChild(textarea);
						textarea.focus();
						textarea.select();
				
						try {
						  document.execCommand("copy");
						//  alert("URL copied (fallback)!");
						  $(".copyLinkPopup").show();		 
				          setTimeout(function(){$(".copyLinkPopup").hide();}, 2000);
					      $('.ShareDropdown').removeClass("active");
						  
						} catch (err) {
						  console.error("Fallback copy failed:", err);
						}
				
						document.body.removeChild(textarea);
					  }
					</script>
											<p class="mb5px"><b>Duration :</b> 
						7 Nights / 8 Days 
						</p>
												<p class="mb5px"><b>Destination Covered :</b> Madurai, Rameshwaram, Kanyakumari</p>
												<p class="mb5px"><b>Tour Activities :</b> Religious & Pilgrimage</p>
												<p class="mb5px"><b>Tour Themes : </b>Religious & Pilgrimage</p>
													<p class="mb5px"><b>Min & Max. PAX :</b> 
							Max : 15					    	</p>
													<div class="fo mt20px mb20px ac xxlarge">
          				<p class="xxlarge b dif mb2px">
						<i class="fa fa-inr"></i> 16500						</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.shreeganeshaholidays.com/enquiry-form-10028.htm">
					<input type="hidden" name="subject" value="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru - Tour Package"/>
					<input type="hidden" name="allocate_type" value="tour"/>							
					<input type="hidden" name="pkg_slno" value="196511"/>
					</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">Madurai, Rameshwaram and Kanyakumari Tour Overview</h2>
				   													</div>
								<p class="large">					
								South India is well known for its brightly decorated temples, cultural monuments, Ayurvedic treatments and mouth-watering dishes.  In this land of temple spires, the devout and the connoisseur of art both pay homage. Kerala tours, which include glittering beaches, lush hill stations, resplendent waterfalls and sprawling plantations and are amongst the most popular of family vacation options in all the South India tour packages. Besides the spice and surf of Kerala, highlights of South India include theSouth India is famous for it’s temples which is made in chola dynasty it’s rich in culture and South India is famous for it’s richness in food , culture,beauty and people . South Indian people respect their traditional values and embrace their cultureExplore South India with a Holistic Travel guide, a Personalized Tour Planner, and Holiday Expert to understand its culture, temples, festivals, landscapes, and people. You decide the package, we design you a personal plan.<br />
<br />
Transportation: By A/c Deluxe coach<br />
<br />
Hotel:        Hotel Geethan Residency Tirunnalar, Hotel Rajadhani Madhurai, Hotel Rameswaram Grand, Gopinivas Grand, Seven Hills Trivendrum, Nandini Tourist Home Guruyayur, S V International Kodaikenal or Similar Hotels<br />
<br />
Covered Places:  Madhurai, Rameswaram, Suchindrum and Kanyakumari<br />
<br />
Highlights :<br />
<br />
Well chalked out itinerary, giving enough time to visit all the important sightseeing places.<br />
Professional guide who will engage and enrich your knowledge about tourist spots and<br />
LTC fecilities for State , central and PSUs employees								</p>
								</div>
								</section>
																<section id="s2" class="mt15px">
								<div class="data mb20px m_p25px">
		  						<div class="fw7 xxlarge">
		  										   					<h2 class="fw7">Madurai, Rameshwaram and Kanyakumari 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>Ground Floor, BMTC Bus stand, Yashwanthpur</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_2/33682/311996.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311996.jpg"  height="200"  width="200"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;" loading="lazy" ></a>
											</span> 
											</div>06.00 am Departure from Ground Floor, BMTC Bus stand, Yashwanthpur<br />
11.00 am Arrive at Thiruvannamalai<br />
11.00 am – 12.30 pm Darshan of Lord Arunachaleshwara<br />
12.30 pm – 01.15 pm Lunch at Thiruvannamalai and departure to Chidambaram<br />
04.30 pm – 05.30 pm Darshan of Lord Nataraja<br />
05.30 pm Chidambaram<br />
05.30 pm -07.30 pm Darshan of Lord Shaneeshwara, Thirunallar & halt at Hotel
										</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>BEST OF SOUTH INDIA</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_2/33682/311997.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311997.jpg"  height="200"  width="200"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;" loading="lazy" ></a>
											</span> 
											</div>05.30 am Departure from Thirunallar<br />
07.30 am – 08.45 am Kumbakonam, Darshan of Lord Kumbeshwara & breakfast<br />
08.45 am Departure to Tanjavur<br />
10.00 am – 11.00 am Darshan of Lord Brihadeeshwara<br />
11.00 am Departure to Srirangam<br />
12.30 pm – 02.30 pm Darshan of Lord Ranganathaswamy & Lunch<br />
02.30 pm Departure to Madurai<br />
05.30 pm Madurai- Visit to Meenakshi Sundareshwara Swamy temple & Night halt at Hotel
										</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>BEST OF SOUTH INDIA</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_2/33682/311998.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311998.jpg"  height="200"  width="200"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;" loading="lazy" ></a>
											</span> 
											</div>08.30 am Departure from madurai<br />
11.30 am – 12.00 pm Arrival to Rameshwaram Check in to hotel<br />
12.00 pm Sea Bath and 21 Holy Well Bath & Darshan of Lord Ramanath and Night halt
										</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>BEST OF SOUTH INDIA</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_2/33682/311999.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311999.jpg"  height="200"  width="200"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;" loading="lazy" ></a>
											</span> 
											</div>05.00 am – 06.00 am Spatikalinga Darshan<br />
06.00 am Departure to Tiruchandur<br />
11.00 am – 12.30 pm Visit Sri Subramanya Swamy Temple and Lunch<br />
01.00 pm Departure to Kanyakumari<br />
04.15 pm – 06.00 pm Sunset View,Visit Kanyakaparameshwari Temple & night halt at Hotel
										</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>BEST OF SOUTH INDIA</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_2/33682/312000.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/312000.jpg"  height="200"  width="200"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;" loading="lazy" ></a>
											</span> 
											</div>06.00 am – 07.00 am Sunrise and Breakfast<br />
07.45 am – 09.45 am Visit Vivekananda Rock Memorial<br />
09.45 am Departure to Suchindram<br />
10.15 am – 11.30 am Darshan of Lord Sathu Malaya<br />
11.30 am -12.30 pm Lunch break<br />
12.30 am Departure to Kovalam Beach<br />
03.30 pm – 04.30 pm Visit to Kovalam Beach<br />
04.30 pm Departure to Tiruvananthapuram<br />
05.30 pm to 06.30 pm Darshan of Lord Anantha Padmanabha temple<br />
06.30 pm Night halt at Hotel
										</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>BEST OF SOUTH INDIA</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="showZoomImage6" href="https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/312001.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/312001.jpg"  height="200"  width="200"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;" loading="lazy" ></a>
											</span> 
											</div>05.30 am Departure to Kaladi ,Breakfast on the way<br />
12.30 pm Arrive at Kaladi (Lunch en route)<br />
12.30 pm – 01.00 pm Visit Adi Shankaracharya Ashrama (Birth Place), Kaladi – Lunch break<br />
05.30 pm Arrive at Guruvayur, Darshan of Lord Guruvayurappan & Night halt
										</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>BEST OF SOUTH INDIA</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="showZoomImage7" href="https://ttw.wlimg.com/package-images/photo-big/dir_2/33682/312002.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/312002.jpg"  height="200"  width="200"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;" loading="lazy" ></a>
											</span> 
											</div>06.30 am Departur to Palini and Breakfast on the Way<br />
12.30 pm – 02.30 pm Darshan of Lord Subramaneshwara Swamy temple,Palani & Lunch break<br />
05.30 pm Arrive at Kodaikanal & Night halt
										</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>BEST OF SOUTH INDIA</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_2/33682/312003.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/312003.jpg"  height="200"  width="200"    alt="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" title="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru" class="abtImg themeBdr p5px bw3px bdrAllDashed c10px dib lh0" style="max-width:200px;max-height:200px;" loading="lazy" ></a>
											</span> 
											</div>09.00 am – 05.30 pm Visit Pillar Rock, Green Valley View, Coaker’s Walk, Bryant’s Park (Lunch), Horse Riding, Cycling, Boating in Kodai Lake<br />
06.00 pm Departure to Bengaluru<br />
08.00 pm – 08.45 pm Dindigal – Dinner<br />
06.00 am Tour ends at Bengaluru
										</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('.pro-detail').css('display','none');
								jQuery(".sub-title").click(function(){
									var $this = jQuery(this);
									  jQuery('.w-title').addClass('h15px',400);
									  $this.find('.w-title').removeClass('h15px',400);
									  if($this.hasClass('on')){
										$this.removeClass('on');
										$this.next().slideUp();          	
									  } else {
										jQuery(".sub-title").removeClass('on');
										jQuery('.pro-detail').slideUp();
										$this.addClass('on');
										$this.next().slideDown(); 
									  }		  
									  if($this.find('i').hasClass('fa-angle-up')){
										$this.find('i').removeClass('fa-angle-up').addClass('fa-angle-down');
									  } else {
										$this.find('i').removeClass('fa-angle-down').addClass('fa-angle-up');
									  }
									});
								});
								</script>
								</section>
															<div class="xxlarge mt10px mb10px dib">
										   					<h2 class="fw7">More Details about Madurai, Rameshwaram and Kanyakumari 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>AP (Room + Breakfast + Lunch + Dinner)</li>
																						<li>Hotel</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>N/A</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>
								
								2020-03-28								</div>
								</section>
																<section id="s6">
								<div class="data mb20px m_p25px large">          
								<div class="mb7px"> 
								<p class="fw7 xxlarge mb10px dib">Payments Terms</p>
								</div>
								
								<ul><li>Full Payment</li></ul>					
								</div>
								</section>
														<section id="s7">
						<div class="data mb20px m_p25px large res_table">            
						<div class="mb7px"> 
						<p class="fw7 xxlarge mb10px dib">Price &amp; Rates</p>
						</div>				
				        <table class="mb15px bdrall bdreee w100 p10px20px formTable">
				        	<tr class="headVr b">
			                	<th class="p15px al">No of pax</th>
			                    <th class="p15px al">Age Limit</th>
			                    <th class="p15px al">Price per pax (Rs)</th>
			                </tr>

															<tr>
				            	<td class="p15px"><span class="fw6 tblTitle">No of pax </span> Adult</td>
				                <td class="p15px"><span class="fw6 tblTitle">Age Limit </span> Above 12 years</td>
				                <td class="p15px"><span class="fw6 tblTitle">Price per pax (Rs) </span> 
			                				                		<b class="webrupee">INR</b>
			                					                	<b>16500</b> <small>/
			
			                		Adult			
			                	( With Tax )			
			                		
			                	</small></td>
				            	</tr>
				            									<tr>
				            	<td class="p15px"><span class="fw6 tblTitle">No of pax </span> Family of 3</td>
				                <td class="p15px"><span class="fw6 tblTitle">Age Limit </span> Family of 3 people</td>
				                <td class="p15px"><span class="fw6 tblTitle">Price per pax (Rs) </span> 
			                				                		<b class="webrupee">INR</b>
			                					                	<b>11500</b> <small>/
			
			                		Family of 3			
			                	( With Tax )			
			                		
			                	</small></td>
				            	</tr>
				            					         </table>
						</div>
						</section>
					 							<section id="s8">
						<div class="data mb20px m_p25px large res_table">           
						<div class="mb7px"> 
						<p class="fw7 xxlarge mb10px dib">Accommodation</p>
						</div>				
		
				    	<table class="mb15px bdrall bdreee w100 p10px20px formTable">
						<tr class="headVr b">
						<th class="p15px al">City</th>
						<th class="p15px al">Hotel Name</th>
						<th class="p15px al">Star Rating</th>
						</tr>
						 
									<tr>
							    	<td class="p15px"><span class="fw6 tblTitle">City </span> 
							    	Tamil nadu 
							    	</td>
							        <td class="p15px fw6"><span class="fw6 tblTitle">Hotel Name </span> Hotel Geethan Residency Tirunnalar, Hotel Rajadhani Madhurai, Hotel Rameswaram Grand, Gopinivas Grand, Seven Hills Trivendrum, Nandini Tourist Home Guruyayur, S V International Kodaikenal or Similar Hotels</td>
							        <td class="p15px"><span class="fw6 tblTitle">Star Rating </span> 
							        									        	<span class="dib p5px15px theme2 c3px">4 <i class="fa fa-star small ml1px"></i></span>
								        								        </td>
								    </tr>
															</tbody>
						</table>
						</div>
						</section>
												<section id="s9">
						<div class="data mb20px m_p25px large">             
						<div class="mb7px"> 
						<p class="fw7 xxlarge mb10px dib">Cancellation &amp; Refund Policy</p>
						</div>
								
						<ul><li>Rules for Cancellation: Cancellation from the proposed time of departure Before 48 hours – 10% of the booking amount will be deducted.</li></ul>			
						</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.shreeganeshaholidays.com/forts-palaces-holidays-catid.htm" title="Forts and Palaces Tour Packages">Forts and Palaces Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.shreeganeshaholidays.com/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.shreeganeshaholidays.com/hill-station-holidays-catid.htm" title="Hill Stations & Valleys Tour Packages">Hill Stations & Valleys Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.shreeganeshaholidays.com/honeymoon-holidays-catid.htm" title="Honeymoon Tour Packages">Honeymoon Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.shreeganeshaholidays.com/lakes-rivers-holidays-catid.htm" title="Lakes & Rivers Tour Packages">Lakes & Rivers Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.shreeganeshaholidays.com/beach-islands-holidays-catid.htm" title="Beaches and Islands Tour Packages">Beaches and Islands Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.shreeganeshaholidays.com/religious-pilgrimage-holidays-catid.htm" title="Religious & Pilgrimage Tour Packages">Religious & Pilgrimage Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.shreeganeshaholidays.com/adventure-holidays-catid.htm" title="Adventure Tour Packages">Adventure Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.shreeganeshaholidays.com/affordable-budget-holidays-catid.htm" title="Affordable & Budget Tour Packages">Affordable & Budget Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px "><a  href="https://www.shreeganeshaholidays.com/family-holidays-catid.htm" title="Family Tour Packages">Family Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.shreeganeshaholidays.com/food-drink-holidays-catid.htm" title="Food and Drink Tour Packages">Food and Drink Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.shreeganeshaholidays.com/national-parks-holidays-catid.htm" title="Wildlife Sanctuaries & National Parks Tour Packages">Wildlife Sanctuaries & National Parks Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.shreeganeshaholidays.com/trekking-holidays-catid.htm" title="Trekking Tour Packages">Trekking Tours</a></span>
														<span class="dib p5px10px c2px bdr bdree mr7px mb7px spanlist dn"><a  href="https://www.shreeganeshaholidays.com/mountain-biking-holidays-catid.htm" title="Mountain Biking Tour Packages">Mountain Biking 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.shreeganeshaholidays.com/enquiry-form-10028.htm">
						<input type="hidden" name="subject" value="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>							
						<input type="hidden" name="pkg_slno" value="196511"/>
						</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 Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru. Please get in contact with me.</textarea>
					<span class="fl red small"></span>
					</div>
					<div class="fl w100 mb15px df-dt">
					<div class="df-dtc w50 pr5px dateOpt pr"><input type="text" name="dynFrm_arrival_date" id="dynFrm_arrival_date_10029" class="dynFrm_arrival_date" style="padding-left:30px;" placeholder=" Departure Date" /><span class="fl red small"></span></div>
					<div class="df-dtc pl5px"><input type="text" name="dynFrm_duration" id="dynFrm_duration_10029" placeholder="Number of Days" /><span class="fl red small"></span></div>
					</div>  
					<div class="mb15px">
					<input type="text" name="dynFrm_email_id" id="dynFrm_email_id_10029" placeholder="Email" />
					<span class="red small"></span>
					</div> 
					<div class="mb20px fl w100">
					<div class="w60px pr fl ofh">
					<div id="isdpackCode" class="isdCode pr0px">+91</div>
					<select class="contSelect" name="dynFrm_country" id="dynFrm_country" onChange="document.getElementById('phone_package_isd').value=this.value.substr(3, 4); document.getElementById('isdpackCode').innerHTML=this.value.substr(3, 4);">
					
											
						<option value="AF^+93" >Afghanistan +93</option>
					
												
						<option value="CF^+236" >African Republic +236</option>
					
												
						<option value="AL^+355" >Albania +355</option>
					
												
						<option value="DZ^+213" >Algeria +213</option>
					
												
						<option value="AS^+0" >American Samoa +0</option>
					
												
						<option value="AD^+376" >Andorra +376</option>
					
												
						<option value="AO^+244" >Angola +244</option>
					
												
						<option value="AI^+264" >Anguilla +264</option>
					
												
						<option value="AG^+268" >Antigua and Barbuda +268</option>
					
												
						<option value="AR^+54" >Argentina +54</option>
					
												
						<option value="AM^+374" >Armenia +374</option>
					
												
						<option value="AW^+297" >Aruba +297</option>
					
												
						<option value="AU^+61" >Australia +61</option>
					
												
						<option value="AT^+43" >Austria +43</option>
					
												
						<option value="AZ^+994" >Azerbaijan +994</option>
					
												
						<option value="BS^+242" >Bahamas +242</option>
					
												
						<option value="BH^+973" >Bahrain +973</option>
					
												
						<option value="BD^+880" >Bangladesh +880</option>
					
												
						<option value="BB^+246" >Barbados +246</option>
					
												
						<option value="BY^+375" >Belarus +375</option>
					
												
						<option value="BE^+32" >Belgium +32</option>
					
												
						<option value="BZ^+501" >Belize +501</option>
					
												
						<option value="BJ^+229" >Benin +229</option>
					
												
						<option value="BM^+441" >Bermuda +441</option>
					
												
						<option value="BT^+975" >Bhutan +975</option>
					
												
						<option value="BO^+591" >Bolivia +591</option>
					
												
						<option value="BA^+387" >Bosnia and Herzegovina +387</option>
					
												
						<option value="BW^+267" >Botswana +267</option>
					
												
						<option value="BV^+47" >Bouvet +47</option>
					
												
						<option value="BR^+55" >Brazil +55</option>
					
												
						<option value="BN^+673" >Brunei +673</option>
					
												
						<option value="BG^+359" >Bulgaria +359</option>
					
												
						<option value="BF^+226" >Burkina +226</option>
					
												
						<option value="BF^+0" >Burkina Faso +0</option>
					
												
						<option value="BI^+257" >Burundi +257</option>
					
												
						<option value="KH^+855" >Cambodia +855</option>
					
												
						<option value="CM^+237" >Cameroon +237</option>
					
												
						<option value="CA^+1" >Canada +1</option>
					
												
						<option value="CV^+238" >Cape Verde +238</option>
					
												
						<option value="KY^+345" >Cayman Islands +345</option>
					
												
						<option value="236^+236" >Central African Republic +236</option>
					
												
						<option value="TD^+235" >Chad +235</option>
					
												
						<option value="IO^+246" >Chagos +246</option>
					
												
						<option value="CL^+56" >Chile +56</option>
					
												
						<option value="CN^+86" >China +86</option>
					
												
						<option value="CX^+61" >Christmas Island +61</option>
					
												
						<option value="CC^+61" >Cocos +61</option>
					
												
						<option value="CO^+57" >Colombia +57</option>
					
												
						<option value="KM^+269" >Comoros +269</option>
					
												
						<option value="CG^+242" >Congo +242</option>
					
												
						<option value="CK^+682" >Cook Islands +682</option>
					
												
						<option value="RCI^+506" >Costa Rica +506</option>
					
												
						<option value="HR^+385" >Croatia +385</option>
					
												
						<option value="CY^+357" >Cyprus +357</option>
					
												
						<option value="CZ^+420" >Czech Republic +420</option>
					
												
						<option value="DK^+45" >Denmark +45</option>
					
												
						<option value="DJ^+253" >Djibouti +253</option>
					
												
						<option value="DM^+767" >Dominica +767</option>
					
												
						<option value="DO^+809" >Dominican Republic +809</option>
					
												
						<option value="TP^+670" >East Timor +670</option>
					
												
						<option value="EC^+593" >Ecuador +593</option>
					
												
						<option value="EG^+20" >Egypt +20</option>
					
												
						<option value="SV^+503" >El Salvador +503</option>
					
												
						<option value="GQ^+0" >Equatorial Guinea +0</option>
					
												
						<option value="ER^+291" >Eritrea +291</option>
					
												
						<option value="EE^+372" >Estonia +372</option>
					
												
						<option value="ET^+251" >Ethiopia +251</option>
					
												
						<option value="FO^+298" >Faroe +298</option>
					
												
						<option value="FM^+691" >Federated States of Micronesia +691</option>
					
												
						<option value="FJ^+679" >Fiji +679</option>
					
												
						<option value="FI^+358" >Finland +358</option>
					
												
						<option value="FR^+33" >France +33</option>
					
												
						<option value="FX^+590" >France, Metropolitan +590</option>
					
												
						<option value="GF^+594" >French Guiana +594</option>
					
												
						<option value="FP^+689" >French Polynesia +689</option>
					
												
						<option value="TF^+590" >French Southern Territories +590</option>
					
												
						<option value="GA^+241" >Gabon +241</option>
					
												
						<option value="GM^+220" >Gambia +220</option>
					
												
						<option value="GE^+995" >Georgia +995</option>
					
												
						<option value="DE^+49" >Germany +49</option>
					
												
						<option value="GH^+233" >Ghana +233</option>
					
												
						<option value="GI^+350" >Gibraltar +350</option>
					
												
						<option value="GR^+30" >Greece +30</option>
					
												
						<option value="GL^+299" >Greenland +299</option>
					
												
						<option value="GD^+809" >Grenada +809</option>
					
												
						<option value="Gre^+473" >Grenada +473</option>
					
												
						<option value="GP^+590" >Guadeloupe +590</option>
					
												
						<option value="GU^+1" >Guam +1</option>
					
												
						<option value="GT^+502" >Guatemala +502</option>
					
												
						<option value="GN^+224" >Guinea +224</option>
					
												
						<option value="GW^+245" >Guinea-bissau +245</option>
					
												
						<option value="GY^+592" >Guyana +592</option>
					
												
						<option value="HT^+509" >Haiti +509</option>
					
												
						<option value="HM^+61" >Heard and Mc Donald Islands +61</option>
					
												
						<option value="HN^+504" >Honduras +504</option>
					
												
						<option value="HU^+36" >Hungary +36</option>
					
												
						<option value="IS^+354" >Iceland +354</option>
					
												
						<option value="IN^+91"  selected="selected" >India +91</option>
					
												
						<option value="ID^+62" >Indonesia +62</option>
					
												
						<option value="IQ^+964" >Iraq +964</option>
					
												
						<option value="IE^+353" >Ireland +353</option>
					
												
						<option value="Isi^Isiolo" >Isiolo Isiolo</option>
					
												
						<option value="IL^+972" >Israel +972</option>
					
												
						<option value="IT^+39" >Italy +39</option>
					
												
						<option value="CI^+225" >Ivory Coast +225</option>
					
												
						<option value="JM^+876" >Jamaica +876</option>
					
												
						<option value="JP^+81" >Japan +81</option>
					
												
						<option value="JO^+962" >Jordan +962</option>
					
												
						<option value="KZ^+7" >Kazakhstan +7</option>
					
												
						<option value="KE^+254" >Kenya +254</option>
					
												
						<option value="KI^+686" >Kiribati +686</option>
					
												
						<option value="KW^+965" >Kuwait +965</option>
					
												
						<option value="KG^+996" >Kyrgyzstan +996</option>
					
												
						<option value="LA^+856" >Lao People's Democratic Republic +856</option>
					
												
						<option value="LA^+856" >Laos +856</option>
					
												
						<option value="LV^+371" >Latvia +371</option>
					
												
						<option value="LB^+961" >Lebanon +961</option>
					
												
						<option value="LS^+266" >Lesotho +266</option>
					
												
						<option value="LR^+231" >Liberia +231</option>
					
												
						<option value="LY^+218" >Libya +218</option>
					
												
						<option value="LI^+423" >Liechtenstein +423</option>
					
												
						<option value="LT^+370" >Lithuania +370</option>
					
												
						<option value="LU^+352" >Luxembourg +352</option>
					
												
						<option value="MO^+853" >Macau +853</option>
					
												
						<option value="MK^+389" >Macedonia +389</option>
					
												
						<option value="MG^+261" >Madagascar +261</option>
					
												
						<option value="MW^+265" >Malawi +265</option>
					
												
						<option value="MY^+60" >Malaysia +60</option>
					
												
						<option value="MV^+960" >Maldives +960</option>
					
												
						<option value="ML^+223" >Mali +223</option>
					
												
						<option value="MT^+356" >Malta +356</option>
					
												
						<option value="FK^+500" >Malvinas +500</option>
					
												
						<option value="MH^+692" >Marshall Islands +692</option>
					
												
						<option value="MQ^+596" >Martinique +596</option>
					
												
						<option value="MR^+222" >Mauritania +222</option>
					
												
						<option value="MU^+230" >Mauritius +230</option>
					
												
						<option value="YT^+269" >Mayotte +269</option>
					
												
						<option value="MX^+52" >Mexico +52</option>
					
												
						<option value="MD^+0" >Moldova +0</option>
					
												
						<option value="MD^+373" >Moldova (Republic of Moldova) +373</option>
					
												
						<option value="MC^+377" >Monaco +377</option>
					
												
						<option value="MN^+976" >Mongolia +976</option>
					
												
						<option value="ME^+381" >Montenegro +381</option>
					
												
						<option value="MS^+664" >Montserrat +664</option>
					
												
						<option value="MA^+212" >Morocco +212</option>
					
												
						<option value="MZ^+258" >Mozambique +258</option>
					
												
						<option value="MM^+95" >Myanmar +95</option>
					
												
						<option value="NA^+264" >Namibia +264</option>
					
												
						<option value="NR^+674" >Nauru +674</option>
					
												
						<option value="NP^+977" >Nepal +977</option>
					
												
						<option value="NL^+31" >Netherlands +31</option>
					
												
						<option value="AN^+599" >Netherlands Antilles +599</option>
					
												
						<option value="NC^+687" >New Caledonia +687</option>
					
												
						<option value="PG^+675" >New Guinea +675</option>
					
												
						<option value="NZ^+64" >New Zealand +64</option>
					
												
						<option value="NI^+505" >Nicaragua +505</option>
					
												
						<option value="NE^+227" >Niger +227</option>
					
												
						<option value="NG^+234" >Nigeria +234</option>
					
												
						<option value="NU^+683" >Niue +683</option>
					
												
						<option value="NF^+672" >Norfolk Island +672</option>
					
												
						<option value="MP^+670" >Northern Mariana Islands +670</option>
					
												
						<option value="NO^+47" >Norway +47</option>
					
												
						<option value="OM^+968" >Oman +968</option>
					
												
						<option value="PK^+92" >Pakistan +92</option>
					
												
						<option value="PW^+680" >Palau +680</option>
					
												
						<option value="PA^+507" >Panama +507</option>
					
												
						<option value="PG^+0" >Papua New Guinea +0</option>
					
												
						<option value="PY^+595" >Paraguay +595</option>
					
												
						<option value="PE^+51" >Peru +51</option>
					
												
						<option value="PH^+63" >Philippines +63</option>
					
												
						<option value="PN^+872" >Pitcairn +872</option>
					
												
						<option value="PL^+48" >Poland +48</option>
					
												
						<option value="PF^+689" >Polynesia +689</option>
					
												
						<option value="PT^+351" >Portugal +351</option>
					
												
						<option value="PR^+1-787" >Puerto Rico +1-787</option>
					
												
						<option value="QA^+974" >Qatar +974</option>
					
												
						<option value="RE^+262" >Reunion +262</option>
					
												
						<option value="RO^+40" >Romania +40</option>
					
												
						<option value="RU^+7" >Russia +7</option>
					
												
						<option value="RW^+250" >Rwanda +250</option>
					
												
						<option value="KN^+869" >Saint Kitts and Nevis +869</option>
					
												
						<option value="LC^+758" >Saint Lucia +758</option>
					
												
						<option value="VC^+784" >Saint Vincent and the Grenadines +784</option>
					
												
						<option value="WS^+685" >Samoa +685</option>
					
												
						<option value="SM^+378" >San Marino +378</option>
					
												
						<option value="ST^+239" >Sao Tome And Principe +239</option>
					
												
						<option value="SA^+966" >Saudi Arabia +966</option>
					
												
						<option value="SN^+221" >Senegal +221</option>
					
												
						<option value="RS^+381" >Serbia +381</option>
					
												
						<option value="SC^+248" >Seychelles +248</option>
					
												
						<option value="SL^+232" >Sierra Leone +232</option>
					
												
						<option value="SG^+65" >Singapore +65</option>
					
												
						<option value="SK^+421" >Slovakia +421</option>
					
												
						<option value="SI^+386" >Slovenia +386</option>
					
												
						<option value="SB^+677" >Solomon Islands +677</option>
					
												
						<option value="SO^+252" >Somalia +252</option>
					
												
						<option value="ZA^+27" >South Africa +27</option>
					
												
						<option value="GS^+44" >South Georgia and the South Sandwich Islands +44</option>
					
												
						<option value="KR^+82" >South Korea +82</option>
					
												
						<option value="ES^+34" >Spain +34</option>
					
												
						<option value="LK^+94" >Sri Lanka +94</option>
					
												
						<option value="SH^+290" >St. Helena +290</option>
					
												
						<option value="PM^+508" >St. Pierre and Miquelon +508</option>
					
												
						<option value="SD^+249" >Sudan +249</option>
					
												
						<option value="SR^+597" >Suriname +597</option>
					
												
						<option value="SJ^+47" >Svalbard and Jan Mayen Islands +47</option>
					
												
						<option value="SZ^+268" >Swaziland +268</option>
					
												
						<option value="SE^+46" >Sweden +46</option>
					
												
						<option value="CH^+41" >Switzerland +41</option>
					
												
						<option value="TW^+886" >Taiwan +886</option>
					
												
						<option value="TJ^+7" >Tajikistan +7</option>
					
												
						<option value="TZ^+255" >Tanzania +255</option>
					
												
						<option value="TH^+66" >Thailand +66</option>
					
												
						<option value="TG^+228" >Togo +228</option>
					
												
						<option value="TK^+64" >Tokelau +64</option>
					
												
						<option value="TO^+676" >Tonga +676</option>
					
												
						<option value="TT^+868" >Trinidad and Tobago +868</option>
					
												
						<option value="TN^+216" >Tunisia +216</option>
					
												
						<option value="TR^+90" >Turkey +90</option>
					
												
						<option value="TM^+993" >Turkmenistan +993</option>
					
												
						<option value="TC^+649" >Turks and Caicos Islands +649</option>
					
												
						<option value="TV^+688" >Tuvalu +688</option>
					
												
						<option value="AE^+971" >UAE +971</option>
					
												
						<option value="UG^+256" >Uganda +256</option>
					
												
						<option value="UA^+380" >Ukraine +380</option>
					
												
						<option value="UK^+44" >United Kingdom +44</option>
					
												
						<option value="UM^+1" >United States Minor Outlying Islands +1</option>
					
												
						<option value="UY^+598" >Uruguay +598</option>
					
												
						<option value="US^+1" >USA +1</option>
					
												
						<option value="UZ^+998" >Uzbekistan +998</option>
					
												
						<option value="VU^+678" >Vanuatu +678</option>
					
												
						<option value="VA^+0" >Vatican City +0</option>
					
												
						<option value="VA^+39" >Vatican City State (Holy See) +39</option>
					
												
						<option value="VE^+58" >Venezuela +58</option>
					
												
						<option value="VN^+84" >Vietnam +84</option>
					
												
						<option value="VG^+1" >Virgin Islands (British) +1</option>
					
												
						<option value="VI^+1" >Virgin Islands (U.S.) +1</option>
					
												
						<option value="WF^+681" >Wallis and Futuna Islands +681</option>
					
												
						<option value="EH^+212" >Western Sahara +212</option>
					
												
						<option value="YE^+967" >Yemen +967</option>
					
												
						<option value="YU^+381" >Yugoslavia +381</option>
					
												
						<option value="ZR^+243" >Zaire +243</option>
					
												
						<option value="ZM^+260" >Zambia +260</option>
					
												
						<option value="ZW^+263" >Zimbabwe +263</option>
					
											</select>
					</div>									
					<input type="text" name="dynFrm_phone" id="dynFrm_phone_10029" class="fl" style="width:calc(100% - 62px);" placeholder="Mobile No" />
					<span class="fl red small"></span>
					</div>					
										
					<div class="mb5px ac">
					<input type="submit" name="submit" value="Send Enquiry" class="dib theme1 p12px bdr fw6">
					<input type="hidden" name="phone_isd" id="phone_package_isd" value="+91">
					<input type="hidden" name="subject" value="Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru - Tour Package"/>
					<input type="hidden" name="allocate_type" value="tour"/>
					<input type="hidden" name="pkg_slno" value="196511"/>
					<input type="hidden" name="current_url" value="https://www.shreeganeshaholidays.com/tour-packages/bestof-south-india-pilgrimage-holidays-tour-packages-from-bengaluru.htm">
				  	<input type="hidden" name="web_address" value="https://www.shreeganeshaholidays.com">
				  	<input type="hidden" name="inq_thanks_msg" value="Thank you for inquiry.<br /><br />We have received your request. Our Sales Team will soon get in touch with you.<br /><br /><br />">
					<input type="hidden" name="inq_thanks_title" value="Enquiry">
				  	<input type="hidden" name="redirected_url" value="https://www.shreeganeshaholidays.com/thanks.htm">
					<input type="hidden" name="catalog_mi" value="33682">
				  	<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 Kanyakumari, Madurai, Rameshwaram</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.shreeganeshaholidays.com/tour-packages/temple-tourof-south-kashi-rameshwaram.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_2/33682/209090.jpg"  height=""  width=""    alt="Temple Tour Of South Kashi Rameshwaram" title="Temple Tour Of South Kashi Rameshwaram"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.shreeganeshaholidays.com/tour-packages/temple-tourof-south-kashi-rameshwaram.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								4 Nights / 5 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.shreeganeshaholidays.com/tour-packages/temple-tourof-south-kashi-rameshwaram.htm" title="Temple Tour Of South Kashi Rameshwaram"><h3>Temple Tour Of South Kashi Rameshwaram</h3></a></div>
							</div>
							</div>						
							</li>
												
							<li>
							<div class="dib w200px">
  							<div class="dib pr ofh lh0 c5px cp" onclick="location.href='https://www.shreeganeshaholidays.com/tour-packages/madurai-kanyakumari-south-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_2/33682/209085.jpg"  height=""  width=""    alt="Madurai – Kanyakumari South Tour" title="Madurai – Kanyakumari South Tour"  class="bdr p1px" ></div></div>
								<div class="absViewBtn"><a href="https://www.shreeganeshaholidays.com/tour-packages/madurai-kanyakumari-south-tour.htm" class="dib buttonBig p5px15px lh12em c20px">View Packages</a></div>
															</div>
							<div class="al">
															<p class="mt5px alpha75">
								5 Nights / 6 Days 
								</p>
															<div class="h large lh12em mt7px"><a href="https://www.shreeganeshaholidays.com/tour-packages/madurai-kanyakumari-south-tour.htm" title="Madurai – Kanyakumari South Tour"><h3>Madurai – Kanyakumari South Tour</h3></a></div>
							</div>
							</div>						
							</li>
															
						</ul>
						</div>
						</div> 
													<style>
							.relTour-pkg .slider ul li{max-width:214px;margin-bottom:20px;padding-left:5px;padding-right:6px;box-sizing:border-box;margin-right:12px;}
							</style>	
														  
						 </div>
					     </div>
					    </section>
										<section class="pt20px pb20px absTour-Title rel-prop">
				<div class="wrap">
				<div class="fo">     	
				<div class="ac mb7px"><div><h2 class="hd_NT">Explore Tour Packages by Destination</h2></div></div>     	
				<div class="ic" id="1102_3-1">
				<div class="slider">
				<ul class="bxslider988">								
				
					<li>
					<div class="dib pr ofh lh0 c5px"><div class="imgFrame m0a dib w200px h200px"><div class="imgFrame picBg dtc ac vam lh0 w200px h200px">
					<a href="https://www.shreeganeshaholidays.com/packages-in-ooty.htm" title="Packages in Ooty" >
					<img src="https://dynamic.tourtravelworld.com/zsc-header/10263-classified.jpg"  height=""  width=""    alt="Ooty" title="Ooty" ></a>
					</div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.shreeganeshaholidays.com/packages-in-ooty.htm" title="Packages in Ooty">Ooty 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.shreeganeshaholidays.com/packages-in-pondicherry.htm" title="Packages in Pondicherry" >
					<img src="https://dynamic.tourtravelworld.com/zsc-header/10895-classified.jpg"  height=""  width=""    alt="Pondicherry" title="Pondicherry" ></a>
					</div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.shreeganeshaholidays.com/packages-in-pondicherry.htm" title="Packages in Pondicherry">Pondicherry 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.shreeganeshaholidays.com/packages-in-mysore.htm" title="Packages in Mysore" >
					<img src="https://dynamic.tourtravelworld.com/zsc-header/10195-classified.jpg"  height=""  width=""    alt="Mysore" title="Mysore" ></a>
					</div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.shreeganeshaholidays.com/packages-in-mysore.htm" title="Packages in Mysore">Mysore 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.shreeganeshaholidays.com/packages-in-alleppey.htm" title="Packages in Alleppey" >
					<img src="https://dynamic.tourtravelworld.com/zsc-header/10235-classified.jpg"  height=""  width=""    alt="Alleppey" title="Alleppey" ></a>
					</div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.shreeganeshaholidays.com/packages-in-alleppey.htm" title="Packages in Alleppey">Alleppey 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.shreeganeshaholidays.com/packages-in-kochi.htm" title="Packages in Kochi" >
					<img src="https://dynamic.tourtravelworld.com/zsc-header/10216-classified.jpg"  height=""  width=""    alt="Kochi" title="Kochi" ></a>
					</div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.shreeganeshaholidays.com/packages-in-kochi.htm" title="Packages in Kochi">Kochi 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.shreeganeshaholidays.com/packages-in-kodaikanal.htm" title="Packages in Kodaikanal" >
					<img src="https://dynamic.tourtravelworld.com/zsc-header/10253-classified.jpg"  height=""  width=""    alt="Kodaikanal" title="Kodaikanal" ></a>
					</div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.shreeganeshaholidays.com/packages-in-kodaikanal.htm" title="Packages in Kodaikanal">Kodaikanal 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.shreeganeshaholidays.com/packages-in-kodagu.htm" title="Packages in Kodagu" >
					<img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/209071.jpg"  height=""  width=""    alt="Packages in Kodagu" title="Packages in Kodagu" ></a>
					</div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.shreeganeshaholidays.com/packages-in-kodagu.htm" title="Packages in Kodagu">Kodagu 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.shreeganeshaholidays.com/packages-in-madurai.htm" title="Packages in Madurai" >
					<img src="https://dynamic.tourtravelworld.com/zsc-header/10256-classified.jpg"  height=""  width=""    alt="Madurai" title="Madurai" ></a>
					</div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.shreeganeshaholidays.com/packages-in-madurai.htm" title="Packages in Madurai">Madurai 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.shreeganeshaholidays.com/packages-in-idukki.htm" title="Packages in Idukki" >
					<img src="https://dynamic.tourtravelworld.com/zsc-header/10212-classified.jpg"  height=""  width=""    alt="Idukki" title="Idukki" ></a>
					</div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.shreeganeshaholidays.com/packages-in-idukki.htm" title="Packages in Idukki">Idukki 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.shreeganeshaholidays.com/packages-in-kanyakumari.htm" title="Packages in Kanyakumari" >
					<img src="https://dynamic.tourtravelworld.com/zsc-header/10250-classified.jpg"  height=""  width=""    alt="Kanyakumari" title="Kanyakumari" ></a>
					</div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.shreeganeshaholidays.com/packages-in-kanyakumari.htm" title="Packages in Kanyakumari">Kanyakumari 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.shreeganeshaholidays.com/packages-in-munnar.htm" title="Packages in Munnar" >
					<img src="https://dynamic.tourtravelworld.com/zsc-header/11226-classified.jpg"  height=""  width=""    alt="Munnar" title="Munnar" ></a>
					</div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.shreeganeshaholidays.com/packages-in-munnar.htm" title="Packages in Munnar">Munnar 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.shreeganeshaholidays.com/packages-in-rameshwaram.htm" title="Packages in Rameshwaram" >
					<img src="https://dynamic.tourtravelworld.com/zsc-header/10268-classified.jpg"  height=""  width=""    alt="Rameshwaram" title="Rameshwaram" ></a>
					</div></div>
					<div class="h xlarge fw6 lh15em"><a href="https://www.shreeganeshaholidays.com/packages-in-rameshwaram.htm" title="Packages in Rameshwaram">Rameshwaram 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:109:"Book Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru - 7 Nights / 8 Days Tour Packages";i:2;s:196:"book best of south india pilgrimage holidays | tour packages from bengaluru - 7 nights / 8 days tour packages, religious & pilgrimage tour packages, madurai, rameshwaram, kanyakumari tour packages";i:3;s:257:"Book Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru - 7 Nights / 8 Days tour packages from Shree Ganesha Tours & Travels - Get attractive 7 Nights / 8 Days Religious & Pilgrimage  tour packages for  Madurai, Rameshwaram, Kanyakumari.";i:4;s:2033:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Madurai, Rameshwaram, Kanyakumari"        
		                 },
		      "description": "South India is well known for its brightly decorated temples, cultural monuments, Ayurvedic treatments and mouth-watering dishes.  In this land of temple spires, the devout and the connoisseur of art both pay homage. Kerala tours, which include glittering beaches, lush hill stations, resplendent waterfalls and sprawling plantations and are amongst the most popular of family vacation options in all the South India tour packages. Besides the spice and surf of Kerala, highlights of South India include theSouth India is famous for it’s temples which is made in chola dynasty it’s rich in culture and South India is famous for it’s richness in food , culture,beauty and people . South Indian people respect their traditional values and embrace their cultureExplore South India with a Holistic Travel guide, a Personalized Tour Planner, and Holiday Expert to understand its culture, temples, festivals, landscapes, and people. You decide the package, we design you a personal plan.

Transportation: By A/c Deluxe coach

Hotel:        Hotel Geethan Residency Tirunnalar, Hotel Rajadhani Madhurai, Hotel Rameswaram Grand, Gopinivas Grand, Seven Hills Trivendrum, Nandini Tourist Home Guruyayur, S V International Kodaikenal or Similar Hotels

Covered Places:  Madhurai, Rameswaram, Suchindrum and Kanyakumari

Highlights :

Well chalked out itinerary, giving enough time to visit all the important sightseeing places.
Professional guide who will engage and enrich your knowledge about tourist spots and
LTC fecilities for State , central and PSUs employees",
		      "name": "Best of South India Pilgrimage Holidays | Tour Packages from Bengaluru",
		      "telephone": "+91-9945029977"
		    }
		    </script>
			";i:5;N;i:6;s:71:"https://ttw.wlimg.com/package-images/photo-small/dir_2/33682/311989.jpg";}