a:6:{i:0;s:23974:"				<div class="h1"><h1>Tiger Trail Circuit by Semi Luxury Tourist Train</h1></div>
				<p class="breadcrumb ar uu small"><a href="https://www.grandindiatrip.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="https://www.grandindiatrip.com/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Tiger Trail Circuit by Semi Luxury Tourist Train</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">Tour Code </td>
						<td class="p5px pl0px vat">wildlife tours</td>
						</tr>
												<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">Bandhavgarh, Jabalpur, Kanha</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 39500 Per Person						</td>
						</tr>
												<tr>
						<td class="b p5px dif w125px vat">Special Offer </td>
						<td class="p5px pl0px dif vat">mportant Notes:-<br />
1.The accommodation booked under this ticket is not transferable.<br />
<br />
<br />
2.The voucher is to be carried by the passenger during the journey along with the photo identity card in original and is valid only when presented with this photo identity card. If the relevant photo identity card is not accompanied with this voucher, it will be considered as ticket-less travel and treated accordingly.<br />
<br />
3.The exact train timings are subject to minor modifications. All the travelling passengers must reconfirm the timings with IRCTC, corporate office before the start of their journey.<br />
<br />
4.On demand from ticket checking staff the passenger should produce this voucher along with the above mentioned photo identity card.<br />
<br />
5.Indian Nationals must carry a government issued photo identity card (passport, driving license, PAN card etc.).<br />
<br />
6.IRCTC reserves the right to refuse booking or travel of any passenger without assigning any reason.<br />
<br />
7.No refund or adjustment will be made in the event of interruption / non-use of full or any part of the tour or tour service by a tourist on his own after the commencement of the tour or closure of a sightseeing place or monument due any unknown reasons or closure on account of the decision /order of the local municipal administration /any other government authority / unforeseen events, circumstances, situations etc.<br />
<br />
8.In case any sightseeing being missed on account of the delay in local transportation buses / train due to the reasons beyond our control, no refund shall be made.<br />
<br />
9.Being a group tour, passengers would be required to share the bus / buses and train accommodation with other passengers. In case any passenger / passengers wish to travel in separate bus/buses, he/she should inform IRCTC at least one month in advance. IRCTC would try to make appropriate arrangement for which passenger / passengers would be required to make additional payment. For the smooth operation of the tour, passengers would need to adhere to the instructions given by the Tour Manager from time to time.<br />
<br />
10.Train / Road journey time may exceed the expected travel time due to unforeseen circumstances such as traffic jams, break down of buses etc. This may result in late meal service, shortened / late/or no sightseeing etc.<br />
<br />
11.Meals in hotels and on train are of pre-fixed menus and are generally decided keeping the palate of the overall tourists. Menus according to the specific preferences would not be possible.<br />
<br />
12.As per the tour itinerary, hotel rooms at certain places are only provided for wash & change purpose. Passengers should not expect rooms to be given to them for longer duration. Check-in at hotel rooms at certain places may be delayed to the due delay from hotel in providing the rooms.<br />
<br />
13. a] AC First class - has cabins with 4 berths (two lower & two upper). The cabins can be locked from inside as it has a sliding door.<br />
<br />
b] AC First class Coupe - has cabins with 2 berths (one lower & one upper). The cabins can be locked from inside as it hasa sliding door.<br />
<br />
14.Passengers are required to take care of their luggage / belongings themselves. IRCTC will not be responsible for any loss or damage of any of the luggage / belongings at the Railway Stations / Train / Bus / Hotels etc.<br />
<br />
15.It is the responsibility of the tourist to carefully read and fully understand all the terms and conditions / services to be offered / type of services to be offered etc. of this tour before making booking. In case of any doubts / clarifications, the same should be cleared with IRCTC before making the booking.<br />
<br />
16.The journeys are well planned in advance. We reserve the right to make changes to the programme if necessary at any point of time. Should the minimum number of passengers not be met or due to certain operational reasons & conditions, we reserve the right to cancel the departure or amend the same. Most of the changes made by us would be minor, but on certain occasions there could be possibility of making significant change. A change is defined as significant if it involves change of date or destination. In such an eventuality, we would inform the passengers on the contact details given by them in their booking forms. In such cases, we would inform you as soon as possible and provide you following solutions :<br />
<br />
(a) Accepting the changed arrangements or transferring your tour to another available tour date.<br />
<br />
(b) Cancelling or accepting the cancellation where you will receive a refund of payment without interest remitted to us. However, there will be no refund of any service such as pre /post tour accommodation, airline tickets, visa charges etc. that have been booked by you and /or your travel agent.<br />
<br />
17. Trip would be operational subject to booking of a minimum 60% of total occupancy on a particular trip & IRCTC reserve the right to cancel/modify the trip at any time without assigning any reason whatsoever.<br />
<br />
18. Do's & Don't in context of Wildlife must be strictly followed. <br />
<br />
DO's<br />
1. Enter the Park with a valid permit.<br />
2. Take official guide with you inside the Park.<br />
3. Drive slow; maximum speed limit is 20 km/hr.<br />
4. Always carry drinking water.<br />
5. Maintain silence and discipline during excursions.<br />
6. Allow the animals to have the right of the way.<br />
7. Wear colors which match with Nature. <br />
DONT's<br />
1. Don't get down, unless told by the guide.<br />
2. Don't carry arms, explosives or intoxicants inside the Park.<br />
3. Don't blow horn.<br />
4. Don't litter with cans, bottles, plastic bags etc.<br />
5. Don't try to feed the animals.<br />
6. Don't smoke or lit fire.<br />
7. Don't tease or chase the animals.<br />
8. Don't leave Plastic/Polybags.</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Tiger Trail Circuit by Semi Luxury Tourist Train - 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="58735"/>
						</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_9/257644/111045.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/111045.jpg"  width="150" height="150"    alt="Tiger Trail Circuit by Semi Luxury Tourist Train" title="Tiger Trail Circuit by Semi Luxury Tourist Train" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Description:<br />
Indian Railways in collaboration with IRCTC proudly announces Tiger Trail Circuit by Semi Luxury Tourist Train. India is known as one of the favorite place for Tiger sightings in the world. IRCTC proudly launches the departure of its new itinerary on Tiger Trail Circuit by Rajdhani type Air-Conditioned train and all surface transportation by A/C vehicles. <br />
<br />
This fascinating odyssey will cover Bandhavgarh & Kanha (Madhya Pradesh) on its Tiger Trail Circuit including visit to Dhuadhar Falls of Bhedaghat/Jabalpur in 05 nights & 06 days. This train journey is scheduled to operate on World Environment Day i.e. 05th June 16 (Sunday)....<br />
IRCTC Buddhist Train Booking<br />
Package Details<br />
 Package Name<br />
 Tiger Trail Circuit by Semi Luxury Tourist Train<br />
 Destination Covered<br />
 Bandhavgarh - Kanha - Jabalpur (Madhya Pradesh)<br />
 Traveling Mode<br />
 Semi Luxury Tourist Train & A/c Transportation.<br />
 Class<br />
 1AC, 2AC<br />
 Departure Date<br />
 <br />
05-June-2016mportant Notes:-<br />
1.The accommodation booked under this ticket is not transferable.<br />
<br />
<br />
2.The voucher is to be carried by the passenger during the journey along with the photo identity card in original and is valid only when presented with this photo identity card. If the relevant photo identity card is not accompanied with this voucher, it will be considered as ticket-less travel and treated accordingly.<br />
<br />
3.The exact train timings are subject to minor modifications. All the travelling passengers must reconfirm the timings with IRCTC, corporate office before the start of their journey.<br />
<br />
4.On demand from ticket checking staff the passenger should produce this voucher along with the above mentioned photo identity card.<br />
<br />
5.Indian Nationals must carry a government issued photo identity card (passport, driving license, PAN card etc.).<br />
<br />
6.IRCTC reserves the right to refuse booking or travel of any passenger without assigning any reason.<br />
<br />
7.No refund or adjustment will be made in the event of interruption / non-use of full or any part of the tour or tour service by a tourist on his own after the commencement of the tour or closure of a sightseeing place or monument due any unknown reasons or closure on account of the decision /order of the local municipal administration /any other government authority / unforeseen events, circumstances, situations etc.<br />
<br />
8.In case any sightseeing being missed on account of the delay in local transportation buses / train due to the reasons beyond our control, no refund shall be made.<br />
<br />
9.Being a group tour, passengers would be required to share the bus / buses and train accommodation with other passengers. In case any passenger / passengers wish to travel in separate bus/buses, he/she should inform IRCTC at least one month in advance. IRCTC would try to make appropriate arrangement for which passenger / passengers would be required to make additional payment. For the smooth operation of the tour, passengers would need to adhere to the instructions given by the Tour Manager from time to time.<br />
<br />
10.Train / Road journey time may exceed the expected travel time due to unforeseen circumstances such as traffic jams, break down of buses etc. This may result in late meal service, shortened / late/or no sightseeing etc.<br />
<br />
11.Meals in hotels and on train are of pre-fixed menus and are generally decided keeping the palate of the overall tourists. Menus according to the specific preferences would not be possible.<br />
<br />
12.As per the tour itinerary, hotel rooms at certain places are only provided for wash & change purpose. Passengers should not expect rooms to be given to them for longer duration. Check-in at hotel rooms at certain places may be delayed to the due delay from hotel in providing the rooms.<br />
<br />
13. a] AC First class - has cabins with 4 berths (two lower & two upper). The cabins can be locked from inside as it has a sliding door.<br />
<br />
b] AC First class Coupe - has cabins with 2 berths (one lower & one upper). The cabins can be locked from inside as it hasa sliding door.<br />
<br />
14.Passengers are required to take care of their luggage / belongings themselves. IRCTC will not be responsible for any loss or damage of any of the luggage / belongings at the Railway Stations / Train / Bus / Hotels etc.<br />
<br />
15.It is the responsibility of the tourist to carefully read and fully understand all the terms and conditions / services to be offered / type of services to be offered etc. of this tour before making booking. In case of any doubts / clarifications, the same should be cleared with IRCTC before making the booking.<br />
<br />
16.The journeys are well planned in advance. We reserve the right to make changes to the programme if necessary at any point of time. Should the minimum number of passengers not be met or due to certain operational reasons & conditions, we reserve the right to cancel the departure or amend the same. Most of the changes made by us would be minor, but on certain occasions there could be possibility of making significant change. A change is defined as significant if it involves change of date or destination. In such an eventuality, we would inform the passengers on the contact details given by them in their booking forms. In such cases, we would inform you as soon as possible and provide you following solutions :<br />
<br />
(a) Accepting the changed arrangements or transferring your tour to another available tour date.<br />
<br />
(b) Cancelling or accepting the cancellation where you will receive a refund of payment without interest remitted to us. However, there will be no refund of any service such as pre /post tour accommodation, airline tickets, visa charges etc. that have been booked by you and /or your travel agent.<br />
<br />
17. Trip would be operational subject to booking of a minimum 60% of total occupancy on a particular trip & IRCTC reserve the right to cancel/modify the trip at any time without assigning any reason whatsoever.<br />
<br />
18. Do's & Don't in context of Wildlife must be strictly followed. <br />
<br />
DO's<br />
1. Enter the Park with a valid permit.<br />
2. Take official guide with you inside the Park.<br />
3. Drive slow; maximum speed limit is 20 km/hr.<br />
4. Always carry drinking water.<br />
5. Maintain silence and discipline during excursions.<br />
6. Allow the animals to have the right of the way.<br />
7. Wear colors which match with Nature. <br />
DONT's<br />
1. Don't get down, unless told by the guide.<br />
2. Don't carry arms, explosives or intoxicants inside the Park.<br />
3. Don't blow horn.<br />
4. Don't litter with cans, bottles, plastic bags etc.<br />
5. Don't try to feed the animals.<br />
6. Don't smoke or lit fire.<br />
7. Don't tease or chase the animals.<br />
8. Don't leave Plastic/Polybags.Indian visa fees, if any.<br />
Items of personal nature, e.g. Laundry, Medicine, Alcoholic drinks etc.<br />
Road Transfers to and from Delhi-Safdarjung Railway Station.<br />
Hotel stay in Delhi before & after the trip, air ticket, visa charges etc.<br />
Any other services not mentioned in Package Price Includes.<br />
Fees for Still/ Flash Video camera at the monuments and other places.<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> Delhi Safdarjung (14:30 hrs)
								</p>
								<p class="aj">Departure from Delhi's Safdarjung Railway Station at 1430 hrs. Dinner & Overnight on board.</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> Katni (07:00 hrs)
								</p>
								<p class="aj">Arrive Katni Railway Station @ 0700 hrs. Breakfast on board, proceed for Bandhavgarh for hotel check in & lunch<br />
Later proceed for evening safari (Khitauli Zone). Dinner & overnight at Bandhavgarh Hotel</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> Bandhavgarh (08:00 hrs)
								</p>
								<p class="aj">Morning Breakfast proceed for Kanha. Arrive at Kanha check in & lunch at Hotel. Later proceed for evening safari (Mukki Zone). Dinner & overnight at Hotel.</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> Kanha(13:00 hrs)
								</p>
								<p class="aj">Morning safari (Mukki Zone) in Kanha late morning Breakfast. Lunch at Hotel. Evening time for leisure. Dinner & overnight at Hotel.</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> Kanha - Jabalpur (20:00 hrs)
								</p>
								<p class="aj">After Breakfast proceed for Jabalpur (135 Kms Approx). Lunch at Hotel in Jabalpur. Proceed for Dhuadhar Waterfall in Bedhaghat. High Tea to be provided in the evening before proceeding to Train Station. Dinner & overnight on board.</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> Delhi Safdarjung (19:00 hrs)
								</p>
								<p class="aj">Breakfast and Lunch on board. Arrive at Delhi Safdarjung Railway Station by late evening. Tour Ends with Happy Memories.</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>Transport</li>
																		<li>Transfers</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Indian visa fees, if any.</li><li>
Items of personal nature, e.g. Laundry, Medicine, Alcoholic drinks etc.</li><li>
Road Transfers to and from Delhi-Safdarjung Railway Station.</li><li>
Hotel stay in Delhi before & after the trip, air ticket, visa charges etc.</li><li>
Any other services not mentioned in Package Price Includes.</li><li>
Fees for Still/ Flash Video camera at the monuments and other places.</li></ul><br />
												<p class="large b mb5px dif">Specific Departure Dates :</p>Tour Date:-<br />
Month<br />
Dates<br />
June' 2016<br />
05-June-2016<br />
<br />
Details of Hotels:-<br />
Place<br />
Category<br />
Hotels<br />
Bandhavgarh<br />
Standard<br />
Tiger Den / Bandhavgarh Jungle Lodge<br />
Kanha<br />
Standard<br />
The Bagh Kanha /Infinity Resorts Kanha<br />
												<p class="large b mb5px dif">Departure Cities with rates :</p>Package Details
 Package Name
 Tiger Trail Circuit by Semi Luxury Tourist Train
 Destination Covered
 Bandhavgarh - Kanha - Jabalpur (Madhya Pradesh)
 Traveling Mode
 Semi Luxury Tourist Train & A/c Transportation.
 Class
 1AC, 2AC
 Departure Date
 
05-June-2016

Package Tariff:-
Class	
AC First Class	
Occupancy	Prices(Per Person)
Single Occupancy	Rs. 49500/-
Double Occupancy	Rs. 45500/-
Triple Occupancy	Rs. 44900/-
Child With Bed (5-11yrs)	Rs. 39500/-
AC Two Tier	
Occupancy	Prices(Per Person)
Single Occupancy	Rs. 43500/-
Double Occupancy	Rs. 39000/-
Triple Occupancy	Rs. 38500/-
Child With Bed (5-11yrs)	Rs. 33500/-<br /><br />
											
						<p class="large b mb5px dif">Terms &amp; Conditions :</p>* Some Advance Percentage of total booking amount 
* Airfare/Transport fare to be paid full at one time in advance.~^#^~* Upon cancellation, refund will be made after deducting the Retention Amount. 
* Retention Amount varies as per the number of days left before your package start date. ~^#^~						
    	<p class="h dif xlarge b mb5px">Package Cost</p>
    	<div class="otherDetails aj">Package Tariff:-<br>
Class	<br>
AC First Class	<br>
Occupancy	Prices(Per Person)<br>
Single Occupancy	Rs. 49500/-<br>
Double Occupancy	Rs. 45500/-<br>
Triple Occupancy	Rs. 44900/-<br>
Child With Bed (5-11yrs)	Rs. 39500/-<br>
AC Two Tier	<br>
Occupancy	Prices(Per Person)<br>
Single Occupancy	Rs. 43500/-<br>
Double Occupancy	Rs. 39000/-<br>
Triple Occupancy	Rs. 38500/-<br>
Child With Bed (5-11yrs)	Rs. 33500/-<br>
(A)# Above rates are valid for Indian Citizens only.<br>
<br>
(B)Additional Surcharge of Rs. 4,000/- Per Person will be charged extra from Foreigners for the Safari Booking at Bandhavgarh and Kanha.<br>
<br>
<br>
It is mandatory to mention the number of ID Proof at the time of booking and ensure to carry the same ID proof on while travelling on the trip.</div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="https://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Tiger Trail Circuit by Semi Luxury Tourist Train - 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="58735"/>
						</form>
						</div>
						
						";i:1;s:87:"Book Tiger Trail Circuit by Semi Luxury Tourist Train - 5 Nights / 6 Days Tour Packages";i:2;s:166:"book tiger trail circuit by semi luxury tourist train - 5 nights / 6 days tour packages, wildlife and nature tour packages, bandhavgarh, jabalpur, kanha tour packages";i:3;s:210:"Grand India Tours & Travels offers Tiger Trail Circuit by Semi Luxury Tourist Train - 5 Nights / 6 Days tour package, budget Wildlife and Nature tour packages for Bandhavgarh, Jabalpur, Kanha at exciting price.";i:4;s:7446:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Bandhavgarh, Jabalpur, Kanha"        
		                 },
		      "description": "Description:
Indian Railways in collaboration with IRCTC proudly announces Tiger Trail Circuit by Semi Luxury Tourist Train. India is known as one of the favorite place for Tiger sightings in the world. IRCTC proudly launches the departure of its new itinerary on Tiger Trail Circuit by Rajdhani type Air-Conditioned train and all surface transportation by A/C vehicles. 

This fascinating odyssey will cover Bandhavgarh & Kanha (Madhya Pradesh) on its Tiger Trail Circuit including visit to Dhuadhar Falls of Bhedaghat/Jabalpur in 05 nights & 06 days. This train journey is scheduled to operate on World Environment Day i.e. 05th June 16 (Sunday)....
IRCTC Buddhist Train Booking
Package Details
 Package Name
 Tiger Trail Circuit by Semi Luxury Tourist Train
 Destination Covered
 Bandhavgarh - Kanha - Jabalpur (Madhya Pradesh)
 Traveling Mode
 Semi Luxury Tourist Train & A/c Transportation.
 Class
 1AC, 2AC
 Departure Date
 
05-June-2016mportant Notes:-
1.The accommodation booked under this ticket is not transferable.


2.The voucher is to be carried by the passenger during the journey along with the photo identity card in original and is valid only when presented with this photo identity card. If the relevant photo identity card is not accompanied with this voucher, it will be considered as ticket-less travel and treated accordingly.

3.The exact train timings are subject to minor modifications. All the travelling passengers must reconfirm the timings with IRCTC, corporate office before the start of their journey.

4.On demand from ticket checking staff the passenger should produce this voucher along with the above mentioned photo identity card.

5.Indian Nationals must carry a government issued photo identity card (passport, driving license, PAN card etc.).

6.IRCTC reserves the right to refuse booking or travel of any passenger without assigning any reason.

7.No refund or adjustment will be made in the event of interruption / non-use of full or any part of the tour or tour service by a tourist on his own after the commencement of the tour or closure of a sightseeing place or monument due any unknown reasons or closure on account of the decision /order of the local municipal administration /any other government authority / unforeseen events, circumstances, situations etc.

8.In case any sightseeing being missed on account of the delay in local transportation buses / train due to the reasons beyond our control, no refund shall be made.

9.Being a group tour, passengers would be required to share the bus / buses and train accommodation with other passengers. In case any passenger / passengers wish to travel in separate bus/buses, he/she should inform IRCTC at least one month in advance. IRCTC would try to make appropriate arrangement for which passenger / passengers would be required to make additional payment. For the smooth operation of the tour, passengers would need to adhere to the instructions given by the Tour Manager from time to time.

10.Train / Road journey time may exceed the expected travel time due to unforeseen circumstances such as traffic jams, break down of buses etc. This may result in late meal service, shortened / late/or no sightseeing etc.

11.Meals in hotels and on train are of pre-fixed menus and are generally decided keeping the palate of the overall tourists. Menus according to the specific preferences would not be possible.

12.As per the tour itinerary, hotel rooms at certain places are only provided for wash & change purpose. Passengers should not expect rooms to be given to them for longer duration. Check-in at hotel rooms at certain places may be delayed to the due delay from hotel in providing the rooms.

13. a] AC First class - has cabins with 4 berths (two lower & two upper). The cabins can be locked from inside as it has a sliding door.

b] AC First class Coupe - has cabins with 2 berths (one lower & one upper). The cabins can be locked from inside as it hasa sliding door.

14.Passengers are required to take care of their luggage / belongings themselves. IRCTC will not be responsible for any loss or damage of any of the luggage / belongings at the Railway Stations / Train / Bus / Hotels etc.

15.It is the responsibility of the tourist to carefully read and fully understand all the terms and conditions / services to be offered / type of services to be offered etc. of this tour before making booking. In case of any doubts / clarifications, the same should be cleared with IRCTC before making the booking.

16.The journeys are well planned in advance. We reserve the right to make changes to the programme if necessary at any point of time. Should the minimum number of passengers not be met or due to certain operational reasons & conditions, we reserve the right to cancel the departure or amend the same. Most of the changes made by us would be minor, but on certain occasions there could be possibility of making significant change. A change is defined as significant if it involves change of date or destination. In such an eventuality, we would inform the passengers on the contact details given by them in their booking forms. In such cases, we would inform you as soon as possible and provide you following solutions :

(a) Accepting the changed arrangements or transferring your tour to another available tour date.

(b) Cancelling or accepting the cancellation where you will receive a refund of payment without interest remitted to us. However, there will be no refund of any service such as pre /post tour accommodation, airline tickets, visa charges etc. that have been booked by you and /or your travel agent.

17. Trip would be operational subject to booking of a minimum 60% of total occupancy on a particular trip & IRCTC reserve the right to cancel/modify the trip at any time without assigning any reason whatsoever.

18. Do's & Don't in context of Wildlife must be strictly followed. 

DO's
1. Enter the Park with a valid permit.
2. Take official guide with you inside the Park.
3. Drive slow; maximum speed limit is 20 km/hr.
4. Always carry drinking water.
5. Maintain silence and discipline during excursions.
6. Allow the animals to have the right of the way.
7. Wear colors which match with Nature. 
DONT's
1. Don't get down, unless told by the guide.
2. Don't carry arms, explosives or intoxicants inside the Park.
3. Don't blow horn.
4. Don't litter with cans, bottles, plastic bags etc.
5. Don't try to feed the animals.
6. Don't smoke or lit fire.
7. Don't tease or chase the animals.
8. Don't leave Plastic/Polybags.Indian visa fees, if any.
Items of personal nature, e.g. Laundry, Medicine, Alcoholic drinks etc.
Road Transfers to and from Delhi-Safdarjung Railway Station.
Hotel stay in Delhi before & after the trip, air ticket, visa charges etc.
Any other services not mentioned in Package Price Includes.
Fees for Still/ Flash Video camera at the monuments and other places.",
		      "name": "Tiger Trail Circuit by Semi Luxury Tourist Train",
		      "telephone": "+91-9415285186"
		    }
		    </script>
			";i:5;N;}