a:6:{i:0;s:18905:"				<div class="h1"><h1>Colorful Rajasthan Trip Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.trishmitours.co.in/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.trishmitours.co.in/packages.htm" title="Packages">Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Colorful Rajasthan Trip Tour</p>
				<br />
				
								
						<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>
					
					<br />
					<div class="data">
					<table class="w100 formTable bdr0 imgWidth">
					<tr>
					<td class="p10px">
					<table class="w100 packageForm">
											<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						5 Nights / 6 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Jaipur, Jaisalmer, Jodhpur, Mount Abu, Pushkar, Udaipur</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 49928 Per Person						</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.trishmitours.co.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Colorful Rajasthan Trip Tour - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>
						<a href="#" onclick="document.getElementById('frmpackagedetail').submit();" class="button p7px pl12px pr12px c5px b large dib mt10px">Book Your Tour</a>
						<input type="hidden" name="pkg_slno" value="132211"/>
						</form>
						</p>
						</td>
						</tr>
											</table>
					</td>
											<td class="p10px vat imgWidth150 w150px lh0">
						<div class="demo-wrap">
						<ul class="lsn m0px p0px" >
															<li class="bdr bw3px c5px p1px"><div class="dt"><p class="ac vam dtc w150px h150px"><a rel="gall" data-fancybox="showZoomImage" href="https://ttw.wlimg.com/package-images/photo-big/dir_13/367374/210222.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_13/367374/210222.jpg"  width="150" height="150"    alt="Colorful Rajasthan Trip Tour" title="Colorful Rajasthan Trip Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Personal expenses such as laundry, telephone calls, tips & gratuity, mineral water, soft & hard drinks, porterage<br />
Anything not mentioned in the inclusions<br />
Additional sightseeing or extra usage of vehicle, other than mentioned in the itinerary<br />
Entrance Fees & Guide charges<br />
Any cost arising due to natural calamities like, landslides, road blockage, political disturbances (strikes), etc (to be borne by the client, who is directly<br />
payable on the spot)<br />
Any increase in Airlines taxes or fuel price at the time of departure, leading to increase in cost on surface transportation & land arrangements, which may<br />
come into effect prior to departure<br />
Still camera/ video camera charger<br />						<div class="headHr">
			            <p class="p7px b pl10px xlarge">Tour Itinerary</p>
			            </div>
			            
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 1:</b> Arrival Udaipur
								</p>
								<p class="aj">On arrival meet at Udaipur airport /railway station & proceed to hotel. After check in at hotel get ready<br />
for Udaipur city tour. Udaipur which is also know as city of Lakes is one of the most beautiful and<br />
romantic cities in India.. Udaipur is a traditionally planned city originally having eleven gates to enter but<br />
now only five remains. start for Udaipur city tour. Visiting Fateh Sagar, Sehelion-KI-Bari - Queen’s resort<br />
for their friends, Bhartiya Lok kala Museum - a museum of folk and art, it displays a rich collection of folk<br />
dresses, ornaments, puppets, masks, dolls. After that visit City Palace – The largest palace complex of<br />
Rajasthan, Jagdish Temple – built by Maharana Jagat Singh and is dedicated to Lord Vishnu.Enjoy the<br />
relaxing boat ride on Lake Pichhola, the beautiful lake amidst the hills, palaces, temples, bathing<br />
ghats, and embankments has two island palaces Jag Niwas and Jag Mandir. Evening you may go for<br />
shopping as well for Paintings, Handloom and Jewellery. Overnight at hotel in Udaipur.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 2:</b> Udaipur - Mount Abu (4.5hr Drive )
								</p>
								<p class="aj">Post breakfast check out from hotel & proceed by surface to Mount Abu which is the only hill station of<br />
Royal Rajasthan, on arrival check in at hotel & enjoy this hilly place, you can visit Dilwara Temple - The<br />
Dilwara Temples of India are located about 2½ kilometres from Mount Abu, Dilwara temples are believed<br />
to be most beautiful example of architectural perfection, this temple carved entirely out of white marble<br />
was built in 1031 A.D. These are famous for their use of marble and intricate marble carvings. Also<br />
enjoy boating at Nakki Lake (direct payment). Boating in the lake and horse rides around the lake are<br />
available (on direct payment). Transfer back to hotel. Overnight at hotel in Mount Abu.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 3:</b> Mount Abu - Jodhpur (4.5 hrs Drive)
								</p>
								<p class="aj">Post breakfast check out from hotel & drive to Jodhpur, on arrival check in at hotel. Jodhpur is the home<br />
of Rathores, Rao Jodha founded Jodhpur in 1459AD. The city is situated at the foot of a hillock protected<br />
by the eight gates facing in various directions. Afternoon enjoy sightseeing tour visit the soaring 125 mt<br />
above the plains The Mehrangarh Fort. The fort has four gates approaching by a winding road. Within the<br />
for there are few magnificent palace named Moti Mahal, Phool Mahal, Sheesh Maahal, Sileh Mahal and<br />
Daulat Khana. Later we will visit to Jaswant Thada; a royal cenotaph in white marble built in 1899AD in the<br />
memory of Maharaja Jaswant Singh II and Umaid Bhawan Palace. You can explore the local markets for<br />
Handicrafts, White metal Curios, Silverware, Quilts, Tie & Dye fabrics, Leather goods, Paintings. Overnight<br />
at hotel in Jodhpur.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 4:</b> Jodhpur - Jaisalmer (6 hrs Drive )
								</p>
								<p class="aj">Post breakfast check out from hotel & drive to Jaisalmer, on arrival visit The Fort (IF TIME PERMITS),<br />
housing the entire township within it the Golden hued fort is a sentinel to the bleak desertscape from its<br />
80 meter high perch on the hill. With the Fort, there are some beautiful Havelis, Jain Temples, and five<br />
interconnected palaces. Now proceed to Sand dunes to check in your desert deluxe camp, enjoy Camel<br />
ride during sunset & then transfer to your camp. Evening enjoy folk dance with dinner.<br />
 Overnight at deluxe camp.</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 5:</b> Jaisalmer - Jaipur (10hrs Drive)
								</p>
								<p class="aj">Post breakfast at Camp, check out & proceed by surface to Jaipur . Named after its founder Maharaja<br />
Sawai Jai Singh II was established on 18 November 1727. Jaipur is considered as the first planned city in<br />
the country. In 1878AD, Jaipur was painted with Pink color to welcome Prince Albert, consort of Queen<br />
Victoria and since then the city is also known as “Pink City”. On arrival check in at hotel. Evening enjoy<br />
shopping in colourful bazaar for Jewellery, Textiles, Handloon & Handicrafts. Overnight at hotel in Jaipur</p>
								</td>
								</tr>
								</table>					
								</div>
								<div class="data">
								<table class="w100 formTable bdr0 imgWidth">
								<tr>
								<td class="p10px vat">
								<p class="b large mb5px"><b class="dif">Day 6:</b> Jaipur Departure
								</p>
								<p class="aj">Post breakfast check out from hotel & enjoy Jaipur sightseeing tour. Early morning first visit Amber City as<br />
an excursion- the capital of Kachhwahas for six centuries before the foundation of Jaipur City. Ascend the<br />
Amber Fort with a traditional royal experience of Elephant ride (Optional). Within the Fort complex we will<br />
visit Sheesh Mahal, Diwan-e-Aam and Dowan-e-Khas. Later drive back to Pink City. En-route a short photoshoot<br />
in-front the Jal Mahal, a small palace set in the middle of Man Sagar Lake.<br />
Afternoon visit to the City Palace, situated in the heart of the old city occupies about one seventh of the<br />
Old City. Within the City Palace we will visit Mubarak Mahal, Clock Tower and City Palace Museum, Later<br />
we will visit Jantar Mantar Observatory, built in 18th century by Maharaja Sawai Jai Singh to study the<br />
movement of constellations and stars in the sky. The enormous sun dials still provides the accurate time.<br />
Before returning to your hotel, take pictures in-front the Hawa Mahal, ‘Palace of Winds’ a five storied<br />
semi-octagonal building having 152 windows was built in 1799 AD by Maharaja Pratap Singh for the royal<br />
ladies to enjoy the processions and other royal activities on the street. Evening enjoy shopping in<br />
colourful bazaar for Jewellery, Textiles, Handloon & Handicrafts (IF TIME PERMITS). On time transfer to<br />
airport / railway station to board the flight / train for onwards journey.</p>
								</td>
								</tr>
								</table>					
								</div>						<br />
												 <p class="headHr p7px b pl10px xlarge">Tour Detail</p>
			             <div class="data p15px aj">
										
						<p class="large b mb5px dif">Inclusions :</p>
						<ul>
															<li>Hotel</li>
																		<li>Meals</li>
																		<li>Sightseeing</li>
																<li>Sightseeing as per the itinerary</li><li>
06 Breakfast, 06 Lunch or 06 Dinner at the hotels mentioned</li><li>
Accommodation for 6 nights 7 days on double sharing basis</li><li>
All Transfers, excursions & sightseeing as per the itinerary by private TATA Indigo in Deluxe Package</li><li>
Below 5 Yrs Child sharing same bed with parents will be Complimentary.</li><li>
Parking and all transport related expense including Driver Services</li><li>
All toll taxes, parking fees, Fuel and driver's allowances</li><li>
Welcome drink on arrival</li><li>
All Transport & Hotels Related Taxes</li><li>
GST & all Government Taxes</li><li>
A 24 - hour helpline.</li><li>
Assistance on Arrival.</li><li>
No Hidden Cost</li>
													</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Personal expenses such as laundry, telephone calls, tips & gratuity, mineral water, soft & hard drinks, porterage</li><li>
Anything not mentioned in the inclusions</li><li>
Additional sightseeing or extra usage of vehicle, other than mentioned in the itinerary</li><li>
Entrance Fees & Guide charges</li><li>
Any cost arising due to natural calamities like, landslides, road blockage, political disturbances (strikes), etc (to be borne by the client, who is directly</li><li>
payable on the spot)</li><li>
Any increase in Airlines taxes or fuel price at the time of departure, leading to increase in cost on surface transportation & land arrangements, which may</li><li>
come into effect prior to departure</li><li>
Still camera/ video camera charger</li></ul><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p><p><strong>PAYMENT POLICY </strong>&bull; Deposit of 25% of the package cost at the time of booking. &bull; Need 50% payment of the package cost, 30 days prior to departure date &bull; Need 100% payment of the package cost, 15 days prior to departure date~^#^~~^#^~<p><strong>IMPORTANT NOTE</strong>

<ul>
	<li>Rates are not valid for Festive peak season. Rates are based on Hotels Subject to Availability at the time of making Reservation. In case of unavailability in mentioned hotels,alternate accommodation will be arranged in a similar category hotel.</li>
	<li>Rates are subject to change if there is any Fair &amp; Festival, Major conference, events in travel destination Early check in / late checks out is subject to availability of rooms.</li>
	<li>Cancellation charges would be as per the company policy.</li>
	<li>Vehicle confirmed will be as per Itinerary and not at disposal. AC will work only in the plains and will be switched off during hill drives.</li>
	<li>All sightseeing mentioned are subject to weather conditions, political conditions &amp; traffic conditions in the destination.</li>
	<li>Any sightseeing missed due to natural calamities / weather conditions is non-refundable.</li>
	<li>All entrances fees will be on direct payment basis as per Itinerary It is not advisable to travel in night, if necessary supplement charge applicable</li>
</ul>

<p><strong>CANCELLATION POLICY</strong>

<ul>
	<li>&nbsp;&nbsp;&nbsp; 10% of full tour cost - 60 days prior to arrival.</li>
	<li>&nbsp;&nbsp;&nbsp; 25% of full tour cost - 30 days prior to arrival.</li>
	<li>&nbsp;&nbsp;&nbsp; 50% of full tour cost - between 15 &amp; 29 days prior to tour.</li>
	<li>&nbsp;&nbsp;&nbsp; 75% of full tour cost - between 14 &amp; 7 days prior to tour</li>
	<li>&nbsp;&nbsp;&nbsp; 100% - within 7 days prior to tour.</li>
</ul>						
    	<p class="h dif xlarge b mb5px">HOTEL DAYAL - UDAIPUR</p>
    	<div class="otherDetails aj">City-centric, this budget property near to the Shukhadia Circle is maintained with 15 guestrooms,<br>
categorized into standard, deluxe, and super deluxe rooms, which is spread across its four floors. The<br>
property is maintained with a roof-top restaurant with the view of Aravalli Mountains and offers sumptuous<br>
fare to its diners.<br>
Distance from Hotel</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">AIRPORT</td>
				<td class="headHr p5px b">BUS STAND</td>
				<td class="headHr p5px b">BUS STAND</td>
				<td class="headHr p5px b">FATEH SAGAR LAKE</td>
				<td class="headHr p5px b">LOK KALA MANDAL</td>
			</tr>
			<tr>
				<td class="data p5px">30</td>
				<td class="data p5px">2</td>
				<td class="data p5px">2</td>
				<td class="data p5px">2</td>
				<td class="data p5px">2</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Hotel Good Luck Residency - MOUNT ABU</p>
    	<div class="otherDetails aj">Hotel Goodluck Residency is located 28 kilometers from the railway station and half a kilometer away from<br>
the bus stand. Ideally located you can conveniently visit the various tourist spots from here, such as Nakki<br>
Lake, Gaumukh Temple, Dilvara Temple and Guru Shikhar.<br>
Distance from Hotel</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Aburoad Railway Station</td>
				<td class="headHr p5px b">Adhar Devi Temple</td>
				<td class="headHr p5px b">Ambaji temple (Gujarat)</td>
				<td class="headHr p5px b">Bus station</td>
				<td class="headHr p5px b">Dilwara Temple</td>
			</tr>
			<tr>
				<td class="data p5px">28</td>
				<td class="data p5px">3</td>
				<td class="data p5px">50</td>
				<td class="data p5px">0</td>
				<td class="data p5px">3</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">The Prem Beacon - JODHPUR</p>
    	<div class="otherDetails aj">Located at a distance of 0.1 km from Route No 10 City Bus Stand, this hotel in Jodhpur has an in-house<br>
restaurant within the premises.<br>
Distance from Hotel</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Bhagat Ki Kothi (Railway Station)</td>
				<td class="headHr p5px b">Digvijay Nagar Garden</td>
				<td class="headHr p5px b">Jodhpur Airport</td>
				<td class="headHr p5px b">Mehrangarh Fort</td>
				<td class="headHr p5px b">Route No 10 City Bus Stand.</td>
			</tr>
			<tr>
				<td class="data p5px">1</td>
				<td class="data p5px">5</td>
				<td class="data p5px">6</td>
				<td class="data p5px">8</td>
				<td class="data p5px">0</td>
			</tr>
		</table></div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.trishmitours.co.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Colorful Rajasthan Trip Tour - Tour Package"/>
						<input type="hidden" name="allocate_type" value="tour"/>
						<a href="#" onclick="document.getElementById('frmpackagedetail').submit();" class="button p7px pl12px pr12px c5px b large dib mt10px">Book Your Tour</a>
						<input type="hidden" name="pkg_slno" value="132211"/>
						</form>
						</div>
						
						";i:1;s:67:"Book Colorful Rajasthan Trip Tour - 5 Nights / 6 Days Tour Packages";i:2;s:161:"book colorful rajasthan trip tour - 5 nights / 6 days tour packages, deserts tour packages, jaipur, jaisalmer, jodhpur, mount abu, pushkar, udaipur tour packages";i:3;s:210:"Book Colorful Rajasthan Trip Tour - 5 Nights / 6 Days tour packages from Trishmi Tours LLP - Get attractive 5 Nights / 6 Days Deserts  tour packages for  Jaipur, Jaisalmer, Jodhpur, Mount Abu, Pushkar, Udaipur.";i:4;s:1141:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Jaipur, Jaisalmer, Jodhpur, Mount Abu, Pushkar, Udaipur"        
		                 },
		      "description": "Personal expenses such as laundry, telephone calls, tips & gratuity, mineral water, soft & hard drinks, porterage
Anything not mentioned in the inclusions
Additional sightseeing or extra usage of vehicle, other than mentioned in the itinerary
Entrance Fees & Guide charges
Any cost arising due to natural calamities like, landslides, road blockage, political disturbances (strikes), etc (to be borne by the client, who is directly
payable on the spot)
Any increase in Airlines taxes or fuel price at the time of departure, leading to increase in cost on surface transportation & land arrangements, which may
come into effect prior to departure
Still camera/ video camera charger",
		      "name": "Colorful Rajasthan Trip Tour",
		      "telephone": "+91-9619101033"
		    }
		    </script>
			";i:5;N;}