a:6:{i:0;s:32478:"				<div class="h1"><h1>Best of Switzerland and Paris Ex New Delhi</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.grandindiatrip.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.grandindiatrip.com/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Best of Switzerland and Paris Ex New Delhi</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">Amezing Switzerland</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						6 Nights / 7 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Paris, Zurich</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 175550 Per Person						</td>
						</tr>
												<tr>
						<td class="b p5px dif w125px vat">Special Offer </td>
						<td class="p5px pl0px dif vat">Visa requirements:-<br />
Visa application (completed and signed by the holder of the passport submitted)<br />
Indian Passport with a validity of at least three months beyond the date of intended stay with two blank pages. Passports valid for more than 10 years will not be accepted as the main required travel document.<br />
Handwritten passports and Passports with manual entry or observations concerning the data pages will not be accepted.<br />
Copy of the valid visas (if any)<br />
Your previous passport if available.<br />
Clear photocopy of the first and last page of the passport.<br />
Two recent passport size colour photographs (35 x 45 mm in width) with a plain light background (white or off-white), close-up 70-80% of the photograph. Photographs taken with a digital camera must be high quality colour and printed on photo-quality paper. One photograph to be pasted (please do not staple) on the visa application form. The second one to be attached with a paper clip to the form (should not be pasted or stapled).Scanned and color photocopies will not be accepted.<br />
A covering letter on a business letterhead from your employer/company stating your position and the length of your service and no objection certificate for the planned trip to Switzerland/Schengen countries, mentioning the dates and the purpose of the trip.<br />
If an applicant is submitting the applications of his/her family, then all applications must have a copy of the covering letter.<br />
Evidence of sufficient financial means and proof of accommodation in Switzerland/Schengen Countries (e.g. hotel confirmation, bookings of the entire stay, receipt of paid package tour). A copy of the confirmed return ticket to India or confirmation of reservation.<br />
A copy of the confirmed return ticket to India or confirmation of reservation.<br />
Personal & company's Income Tax Returns for last 3 years<br />
Latest 6 months personal & company's bank statements should have the bank seal.<br />
Business registration certificate/Partnership Deed/Proof of proprietorship.<br />
For employees: Latest 6 months salary slips and salary bank account statements with bank seal.<br />
For children (under 18 years of age) travelling alone, an authorisation letter signed by both parents with their passports or a notarised affidavit signed by both parents is required.<br />
A copy of the identity card and no objection certificate from the school, institute or college for the planned trip to Switzerland mentioning the dates of the trip.<br />
A copy and original marriage certificate issued by the Registrar of Marriages of the concerned State, duly legalised by the competent State Home Ministry or names of spouses endorsed on the passports.<br />
If you have been refused a visa by an Embassy or High Commission in the last 2 years: Refusal notice or a written explanation about reason for trip and refusal is to be submitted.<br />
Overseas Medical Insurance policy.<br />
Minimum coverage of 30,000 Euro per person.<br />
Coverage of all expenses which might arise in connection with repatriation for medical reasons, urgent medical attention and / or emergency hospital treatment<br />
The insurance has to cover the entire stay in Schengen territory.<br />
Applicants who wish to apply for a six months or one year multiple entry visa are not obliged to provide a 365 (180) day coverage. It will be sufficient to submit an insurance policy covering the first journey. In addition to that a declaration for covering further journeys accordingly needs to be filled and signed by the applicant.<br />
NOC from employer in case of employees.<br />
<br />
Note:-<br />
IRCTC will not encourage visa on arrival.<br />
Kindly ensure that your passport is valid for minimum 3 months beyond the stay, ECNR/POE formalities completed, etc.<br />
Two passport size photographs and copy of passport & pan card in full duly signed by the customer need to be submitted to IRCTC within three days of the booking.<br />
Above rates are subject to availability.<br />
Cancellation charges as per company policy.<br />
Room categories in all packages are the base category rooms unless stated otherwise.<br />
Final confirmation in the proposed hotels is subject to the availability at the time of booking, else similar category hotel will be provided.<br />
Please reach the airport 3 hours before the departure of the flight. IRCTC will not responsible for missing of flights by the guest.<br />
Kindly reconfirm the departure terminal and the flight schedule from the airline before leaving for the airport.<br />
Web check in is not possible in our group packages.<br />
Transfers and Sightseeing tours are on SIC (seat in coach) / shared basis by A/C vehicle.<br />
Arrival / departure transfers & sightseeing tours shall be provided as per schedule. However this may require you to wait at the airport for short duration until all the guests arriving at that time exit the airport.<br />
The request for an adjacent or an adjoining room will be on subject to availability.<br />
It is mandatory to carry the age proof of children (02 to 11 yrs) and infant (below 02yrs) as well along with other travel documents. Child above than 11 yrs shall be considered for an adult cost.<br />
In airline no seat is provided to Infant.<br />
Room allocation (Twin bed / Double bed) is at the discretion of the hotel. Number of meals is always corresponding to the number of nights booked. Breakfast is not provided on the day of arrival.<br />
In hotels for an extra Adult / Child either Rollaway bed or mattress shall be provided.<br />
For early check in and late check out the payment is to be settled directly by the guest.<br />
Hotel has the right to claim the damages incurred by any of the guest.<br />
The guests are requested to take care of their personal belongings carefully and avoid leaving them unattended.<br />
The airfares and taxes are calculated as on a mentioned date and any increase in the Taxes or airfares will be borne by the customer.<br />
For any change in Flight Timings/diversions, Flight cancellation from the airline IRCTC will not be responsible and if it further affects the Sightseeing/Itinerary client need to accommodate accordingly.<br />
Cost of additional services availed by the guest which are not part of our package inclusions are to be settled directly at the hotel.<br />
Buffet/Fixed meal will be provided at fixed venue decided by the hotel.<br />
You are kindly requested to check the perfect buffet timings at the time of check in at the hotel. Once the buffet time is over the hotel might ask you to pay for your meals.<br />
IRCTC request you that before finalizing the tour with us kindly go through the website of the hotels and read the reviews.<br />
Package cost is calculated on lowest class Air Fare. Any increase in air fare or air port taxes has to be borne by the client.<br />
Any Itinerary posted on the website is only a proposed holiday outline.<br />
In case there is any change in price the same will be communicated to yourself and only after your confirmation, we will proceed further.<br />
There will be no refund for un-utilized services.<br />
The package Price is subject to change without prior notice.<br />
Above tour prices are subject to change in the event of increase in hotel room rates levy by the hotel especially during peak season / holiday surcharge and major events/ fairs and convention.<br />
Passenger should get full briefing about the tour from IRCTC before/after the booking to avoid any confusion.<br />
IRCTC is not liable for personnel expenses, boating, porterage, theft, accidents etc.<br />
Any other terms and conditions applied as may be decided by IRCTC at any point of time.</td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Best of Switzerland and Paris Ex New Delhi - 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="58665"/>
						</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/110917.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/110917.jpg"  width="150" height="150"    alt="Switzerland and Paris Ex New Delhi" title="Switzerland and Paris Ex New Delhi" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Description:<br />
Switzerland & Paris:- Europe encompasses an area of 10,180,000 km2 (3,930,000 square miles), stretching from Asia to the Atlantic, and from Africa to the Arctic. European countries welcome more than 480 million international visitors per year, more than half of the global market, and 7 of the 10 most visited countries are European nations. It's easy to see why - a well preserved cultural heritage, open borders and efficient infrastructure makes visiting Europe a breeze, and rarely will you have to travel more than a few hours before you can immerse yourself in a new culture, and dive into a different phrasebook. Although it is the world's smallest continent in land surface area, there are profound differences between the cultures and ways of life in its countries. <br />
IRCTC Flight Packages<br />
Package Details<br />
Package Name Best Of Switzerland And Paris Ex New Delhi<br />
Traveling Mode By Air<br />
Station/Departure Time Delhi Airport at 00:25 Hrs<br />
Class Comfort<br />
Frequency/Tour Date 07th May 2016, 21st May 2016, 04th June 2016 & 18th June 2016<br />
Group Size 20Visa requirements:-<br />
Visa application (completed and signed by the holder of the passport submitted)<br />
Indian Passport with a validity of at least three months beyond the date of intended stay with two blank pages. Passports valid for more than 10 years will not be accepted as the main required travel document.<br />
Handwritten passports and Passports with manual entry or observations concerning the data pages will not be accepted.<br />
Copy of the valid visas (if any)<br />
Your previous passport if available.<br />
Clear photocopy of the first and last page of the passport.<br />
Two recent passport size colour photographs (35 x 45 mm in width) with a plain light background (white or off-white), close-up 70-80% of the photograph. Photographs taken with a digital camera must be high quality colour and printed on photo-quality paper. One photograph to be pasted (please do not staple) on the visa application form. The second one to be attached with a paper clip to the form (should not be pasted or stapled).Scanned and color photocopies will not be accepted.<br />
A covering letter on a business letterhead from your employer/company stating your position and the length of your service and no objection certificate for the planned trip to Switzerland/Schengen countries, mentioning the dates and the purpose of the trip.<br />
If an applicant is submitting the applications of his/her family, then all applications must have a copy of the covering letter.<br />
Evidence of sufficient financial means and proof of accommodation in Switzerland/Schengen Countries (e.g. hotel confirmation, bookings of the entire stay, receipt of paid package tour). A copy of the confirmed return ticket to India or confirmation of reservation.<br />
A copy of the confirmed return ticket to India or confirmation of reservation.<br />
Personal & company's Income Tax Returns for last 3 years<br />
Latest 6 months personal & company's bank statements should have the bank seal.<br />
Business registration certificate/Partnership Deed/Proof of proprietorship.<br />
For employees: Latest 6 months salary slips and salary bank account statements with bank seal.<br />
For children (under 18 years of age) travelling alone, an authorisation letter signed by both parents with their passports or a notarised affidavit signed by both parents is required.<br />
A copy of the identity card and no objection certificate from the school, institute or college for the planned trip to Switzerland mentioning the dates of the trip.<br />
A copy and original marriage certificate issued by the Registrar of Marriages of the concerned State, duly legalised by the competent State Home Ministry or names of spouses endorsed on the passports.<br />
If you have been refused a visa by an Embassy or High Commission in the last 2 years: Refusal notice or a written explanation about reason for trip and refusal is to be submitted.<br />
Overseas Medical Insurance policy.<br />
Minimum coverage of 30,000 Euro per person.<br />
Coverage of all expenses which might arise in connection with repatriation for medical reasons, urgent medical attention and / or emergency hospital treatment<br />
The insurance has to cover the entire stay in Schengen territory.<br />
Applicants who wish to apply for a six months or one year multiple entry visa are not obliged to provide a 365 (180) day coverage. It will be sufficient to submit an insurance policy covering the first journey. In addition to that a declaration for covering further journeys accordingly needs to be filled and signed by the applicant.<br />
NOC from employer in case of employees.<br />
<br />
Note:-<br />
IRCTC will not encourage visa on arrival.<br />
Kindly ensure that your passport is valid for minimum 3 months beyond the stay, ECNR/POE formalities completed, etc.<br />
Two passport size photographs and copy of passport & pan card in full duly signed by the customer need to be submitted to IRCTC within three days of the booking.<br />
Above rates are subject to availability.<br />
Cancellation charges as per company policy.<br />
Room categories in all packages are the base category rooms unless stated otherwise.<br />
Final confirmation in the proposed hotels is subject to the availability at the time of booking, else similar category hotel will be provided.<br />
Please reach the airport 3 hours before the departure of the flight. IRCTC will not responsible for missing of flights by the guest.<br />
Kindly reconfirm the departure terminal and the flight schedule from the airline before leaving for the airport.<br />
Web check in is not possible in our group packages.<br />
Transfers and Sightseeing tours are on SIC (seat in coach) / shared basis by A/C vehicle.<br />
Arrival / departure transfers & sightseeing tours shall be provided as per schedule. However this may require you to wait at the airport for short duration until all the guests arriving at that time exit the airport.<br />
The request for an adjacent or an adjoining room will be on subject to availability.<br />
It is mandatory to carry the age proof of children (02 to 11 yrs) and infant (below 02yrs) as well along with other travel documents. Child above than 11 yrs shall be considered for an adult cost.<br />
In airline no seat is provided to Infant.<br />
Room allocation (Twin bed / Double bed) is at the discretion of the hotel. Number of meals is always corresponding to the number of nights booked. Breakfast is not provided on the day of arrival.<br />
In hotels for an extra Adult / Child either Rollaway bed or mattress shall be provided.<br />
For early check in and late check out the payment is to be settled directly by the guest.<br />
Hotel has the right to claim the damages incurred by any of the guest.<br />
The guests are requested to take care of their personal belongings carefully and avoid leaving them unattended.<br />
The airfares and taxes are calculated as on a mentioned date and any increase in the Taxes or airfares will be borne by the customer.<br />
For any change in Flight Timings/diversions, Flight cancellation from the airline IRCTC will not be responsible and if it further affects the Sightseeing/Itinerary client need to accommodate accordingly.<br />
Cost of additional services availed by the guest which are not part of our package inclusions are to be settled directly at the hotel.<br />
Buffet/Fixed meal will be provided at fixed venue decided by the hotel.<br />
You are kindly requested to check the perfect buffet timings at the time of check in at the hotel. Once the buffet time is over the hotel might ask you to pay for your meals.<br />
IRCTC request you that before finalizing the tour with us kindly go through the website of the hotels and read the reviews.<br />
Package cost is calculated on lowest class Air Fare. Any increase in air fare or air port taxes has to be borne by the client.<br />
Any Itinerary posted on the website is only a proposed holiday outline.<br />
In case there is any change in price the same will be communicated to yourself and only after your confirmation, we will proceed further.<br />
There will be no refund for un-utilized services.<br />
The package Price is subject to change without prior notice.<br />
Above tour prices are subject to change in the event of increase in hotel room rates levy by the hotel especially during peak season / holiday surcharge and major events/ fairs and convention.<br />
Passenger should get full briefing about the tour from IRCTC before/after the booking to avoid any confusion.<br />
IRCTC is not liable for personnel expenses, boating, porterage, theft, accidents etc.<br />
Any other terms and conditions applied as may be decided by IRCTC at any point of time.Lunches during the tour.<br />
Any increase in Airfare<br />
Any increase in Airport Taxes, Fuel Surcharge, Visa fee will be payable by passenger.<br />
Meals are preset and a choice of menu is not available<br />
Any room service will be chargeable.<br />
All kind of tips to drivers, guides, representative, Fuel Surcharge, etc<br />
Any increase in rate of exchange leading to an increase in surface transportation and land arrangements which may come into effect prior to departure. The tour price is subject to increase without notice if this rate changes substantially prior to departure<br />
Any expenses of personal nature such as laundry expenses, wines, food and drinks not in the regular menus provided by us<br />
Anything not included in the inclusions.<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> Arrive Zurich - Transfer to Engelberg
								</p>
								<p class="aj">On arrival, you will be met with Local Representative outside the customs area and Transfer to Engelberg after doing short orientation city tour of Zurich. On arrival check into Hotel. Later, proceed for Lucerne City (35 Kms) tour from Engelberg. Dinner at Indian restaurant. Overnight at your hotel in Engelberg.</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> Mt. Titlis with Ice - Flyer Ride
								</p>
								<p class="aj">After a continental breakfast, proceed for full day excursion to Mt. Titlis. We begin the tour with a visit to Mt. Titlis, which at 10,000 ft. is the highest peak in central Switzerland. As you journey to Mt. Titlis through a series of three different cable car rides, you will be amazed as the scenery changes from green meadows, scenic lakes to snow clad mountains. See over 200 cable cars sporting different flags. Lookout for cable car number 73 that carries the Indian flag! The last leg of the ascent will be in the world's first rotating cable car called the 'Titlis Rotair'. At Mt. Titlis you have free time to play and enjoy in the snow, visit the Ice Cave or just relax at the restaurant. At the Terrace on top of the Mt. Titlis summit station, weather permitting, you could take an unforgettable ride on the "Ice- Flyer" an enclosed ski lift that travels only a few meters over the Titlis Glacier. (weather permitting). Remaining day is Free at own Leisure. Dinner at Indian restaurant. Overnight at your hotel in Engelberg.</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> Jungfraujoch
								</p>
								<p class="aj">After a continental breakfast, Proceed for scenic drive to Lauterbrunnen, from where we board a train to Jungfraujoch, the highest altitude railway station in Europe at 11,333 ft. takes us along lovely lakes and mountain passes. Marvel at the changes in the Alpine scenery as your charming cog-wheel train takes you on a unique journey. Experience the magic of the mountains at the Sphinx Terrace. See the breathtaking Jungfrau Peak and the awesome Aletsch Glacier. Also, visit the Ice Palace, where you see a beautiful display of sculptures made of ice, while being encased in ice yourself. Have a memorable encounter with eternal snow and ice at the Plateau. Thereafter proceed to Interlaken (17 Kms) City Tour, one of Switzerland's best-known health and pleasure City. There's time to relax at the many cafes or shop for Swiss watches, chocolates etc. Dinner at Indian restaurant. Overnight at your hotel in Engelberg.</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> Onto Paris
								</p>
								<p class="aj">After a continental breakfast, check out from hotel and journey (700 Kms, 7 hours drive) towards Paris by Coach. In the Evening, arrive Paris - the fashion capital of the world. On arrival, check into the hotel. Enjoy natural beauty on the way. The evening is free for you to relax. Dinner at Indian restaurant. Overnight at your hotel in Paris.</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> Paris City Tour + Eiffel Tower
								</p>
								<p class="aj">Paris City Tour + Eiffel Tower 2nd Level. Lido Show at Night (Optional)<br />
After Breakfast we start our Guided Paris City Tour. We take you to the 2nd level of Eiffel Tower from where a bird's eye view will leave you breathless. Later, proceed on a panoramic city tour of Paris conducted by a local guide. See Paris in all her charm, glamour and glory. See the Obelisk at Place de la Concorde, the largest and the loveliest of the Parisian squares and the majestic Arc de Triomphe. Also see the Champs Elysees, arguably the most well known avenue in the world, the magnificent Opera, the striking Town Hall and the National Assembly, the famous Notre Dame Cathedral. After City tour Enjoy Indian Dinner at Night. <br />
Today Late Night (23:30) you can enjoy Lido Show (at Extra Cost). See the finest combination of beauty, rhythm and gaiety. Experience the charm of striking ballets, shimmering costumes and talented dance troupes. A perfect end to this beautiful evening!!! Overnight In Paris 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 6:</b> Disneyland
								</p>
								<p class="aj">Today Day enjoy Full day Tour of Disneyland. Day for magic and enchantment. Enjoy breakfast at hotel and proceed to the Disneyland Parks. You will receive a one-day pass for Disneyland parks. The Disneyland Park with its 5 magical lands, exciting rides and attractions, larger-than-life Disney characters and an endless array of shows and parades leaves you breathless for more. The magic never ends here. Dinner at Indian restaurant. Overnight stay in Paris 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 7:</b> Return Home with Wonderful Memories
								</p>
								<p class="aj">After breakfast. Check out from hotel. Transfer to airport for flight back to India.</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>Sightseeing</li>
																		<li>Transport</li>
																		<li>Transfers</li>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Lunches during the tour.</li><li>
Any increase in Airfare</li><li>
Any increase in Airport Taxes, Fuel Surcharge, Visa fee will be payable by passenger.</li><li>
Meals are preset and a choice of menu is not available</li><li>
Any room service will be chargeable.</li><li>
All kind of tips to drivers, guides, representative, Fuel Surcharge, etc</li><li>
Any increase in rate of exchange leading to an increase in surface transportation and land arrangements which may come into effect prior to departure. The tour price is subject to increase without notice if this rate changes substantially prior to departure</li><li>
Any expenses of personal nature such as laundry expenses, wines, food and drinks not in the regular menus provided by us</li><li>
Anything not included in the inclusions.</li></ul><br />
												<p class="large b mb5px dif">Specific Departure Dates :</p>Tour Date - 07th May 2016, 21st May 2016, 04th June 2016 & 18th June 2016<br />
<br />
Flight Details:<br />
Flight No	From   -   To	Dept. Time	Arr. Time<br />
AF225<br />
(Onward)	 DEL - CDG	 00:25 HRS	 06:00 HRS<br />
AF 1114<br />
(Onward)	 CDG - ZRH	 07:45 HRS	 09:00 HRS<br />
AF226<br />
(Return)	 CDG - DEL	 10:45 HRS	 22:35 HRS<br />
The Flight timings or schedule is subject to change as per the airlines operational feasibility<br />
												<p class="large b mb5px dif">Departure Cities with rates :</p>Tour Date - 07th May 2016, 21st May 2016, 04th June 2016 & 18th June 2016
Package Tariff: (Per Person)
Class	
Comfort	
Occupancy	Prices (Per Person)
Single Occupancy	Rs.2,22,200/-
Double Occupancy	Rs.1,74,000/-
Triple Occupancy	Rs.1,73,550/-
Child(02-11yrs) with bed	Rs.1,58,550/-
Child (02-11yrs) without bed	Rs.1,27,600/-<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">The Flight timings or schedule is subject to change as per the airlines operational feasibility.</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="data p5px">Flight No</td>
				<td class="data p5px">From</td>
				<td class="data p5px">To</td>
				<td class="data p5px">Dept. Time</td>
				<td class="data p5px">Arr. Time</td>
			</tr>
			<tr>
				<td class="data p5px">AF225(Onward)</td>
				<td class="data p5px">DEL</td>
				<td class="data p5px">CDG</td>
				<td class="data p5px">00:25 HRS</td>
				<td class="data p5px">06:00 HRS</td>
			</tr>
			<tr>
				<td class="data p5px">AF 1114(Onward)</td>
				<td class="data p5px">CDG</td>
				<td class="data p5px">ZRH</td>
				<td class="data p5px">07:45 HRS</td>
				<td class="data p5px">09:00 HRS</td>
			</tr>
			<tr>
				<td class="data p5px">AF226(Return)</td>
				<td class="data p5px">CDG</td>
				<td class="data p5px">DEL</td>
				<td class="data p5px">10:45 HRS</td>
				<td class="data p5px">22:35 HRS</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Package Tariff: (Per Person)</p>
    	<div class="otherDetails aj">Class	<br>
Comfort	<br>
Occupancy	Prices (Per Person)<br>
Single Occupancy	Rs.2,22,200/-<br>
Double Occupancy	Rs.1,74,000/-<br>
Triple Occupancy	Rs.1,73,550/-<br>
Child(02-11yrs) with bed	Rs.1,58,550/-<br>
Child (02-11yrs) without bed	Rs.1,27,600/-<br>
*Child fare of age below 2 years need to be deposited in cash by customer at IRCTC office at the time of booking.</div><br>						</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.grandindiatrip.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Best of Switzerland and Paris Ex New Delhi - 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="58665"/>
						</form>
						</div>
						
						";i:1;s:81:"Book Best of Switzerland and Paris Ex New Delhi - 6 Nights / 7 Days Tour Packages";i:2;s:143:"book best of switzerland and paris ex new delhi - 6 nights / 7 days tour packages, forts and palaces tour packages, paris, zurich tour packages";i:3;s:187:"Grand India Tours & Travels offers Best of Switzerland and Paris Ex New Delhi - 6 Nights / 7 Days tour package, budget Forts and Palaces tour packages for Paris, Zurich at exciting price.";i:4;s:9675:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Paris, Zurich"        
		                 },
		      "description": "Description:
Switzerland & Paris:- Europe encompasses an area of 10,180,000 km2 (3,930,000 square miles), stretching from Asia to the Atlantic, and from Africa to the Arctic. European countries welcome more than 480 million international visitors per year, more than half of the global market, and 7 of the 10 most visited countries are European nations. It's easy to see why - a well preserved cultural heritage, open borders and efficient infrastructure makes visiting Europe a breeze, and rarely will you have to travel more than a few hours before you can immerse yourself in a new culture, and dive into a different phrasebook. Although it is the world's smallest continent in land surface area, there are profound differences between the cultures and ways of life in its countries. 
IRCTC Flight Packages
Package Details
Package Name Best Of Switzerland And Paris Ex New Delhi
Traveling Mode By Air
Station/Departure Time Delhi Airport at 00:25 Hrs
Class Comfort
Frequency/Tour Date 07th May 2016, 21st May 2016, 04th June 2016 & 18th June 2016
Group Size 20Visa requirements:-
Visa application (completed and signed by the holder of the passport submitted)
Indian Passport with a validity of at least three months beyond the date of intended stay with two blank pages. Passports valid for more than 10 years will not be accepted as the main required travel document.
Handwritten passports and Passports with manual entry or observations concerning the data pages will not be accepted.
Copy of the valid visas (if any)
Your previous passport if available.
Clear photocopy of the first and last page of the passport.
Two recent passport size colour photographs (35 x 45 mm in width) with a plain light background (white or off-white), close-up 70-80% of the photograph. Photographs taken with a digital camera must be high quality colour and printed on photo-quality paper. One photograph to be pasted (please do not staple) on the visa application form. The second one to be attached with a paper clip to the form (should not be pasted or stapled).Scanned and color photocopies will not be accepted.
A covering letter on a business letterhead from your employer/company stating your position and the length of your service and no objection certificate for the planned trip to Switzerland/Schengen countries, mentioning the dates and the purpose of the trip.
If an applicant is submitting the applications of his/her family, then all applications must have a copy of the covering letter.
Evidence of sufficient financial means and proof of accommodation in Switzerland/Schengen Countries (e.g. hotel confirmation, bookings of the entire stay, receipt of paid package tour). A copy of the confirmed return ticket to India or confirmation of reservation.
A copy of the confirmed return ticket to India or confirmation of reservation.
Personal & company's Income Tax Returns for last 3 years
Latest 6 months personal & company's bank statements should have the bank seal.
Business registration certificate/Partnership Deed/Proof of proprietorship.
For employees: Latest 6 months salary slips and salary bank account statements with bank seal.
For children (under 18 years of age) travelling alone, an authorisation letter signed by both parents with their passports or a notarised affidavit signed by both parents is required.
A copy of the identity card and no objection certificate from the school, institute or college for the planned trip to Switzerland mentioning the dates of the trip.
A copy and original marriage certificate issued by the Registrar of Marriages of the concerned State, duly legalised by the competent State Home Ministry or names of spouses endorsed on the passports.
If you have been refused a visa by an Embassy or High Commission in the last 2 years: Refusal notice or a written explanation about reason for trip and refusal is to be submitted.
Overseas Medical Insurance policy.
Minimum coverage of 30,000 Euro per person.
Coverage of all expenses which might arise in connection with repatriation for medical reasons, urgent medical attention and / or emergency hospital treatment
The insurance has to cover the entire stay in Schengen territory.
Applicants who wish to apply for a six months or one year multiple entry visa are not obliged to provide a 365 (180) day coverage. It will be sufficient to submit an insurance policy covering the first journey. In addition to that a declaration for covering further journeys accordingly needs to be filled and signed by the applicant.
NOC from employer in case of employees.

Note:-
IRCTC will not encourage visa on arrival.
Kindly ensure that your passport is valid for minimum 3 months beyond the stay, ECNR/POE formalities completed, etc.
Two passport size photographs and copy of passport & pan card in full duly signed by the customer need to be submitted to IRCTC within three days of the booking.
Above rates are subject to availability.
Cancellation charges as per company policy.
Room categories in all packages are the base category rooms unless stated otherwise.
Final confirmation in the proposed hotels is subject to the availability at the time of booking, else similar category hotel will be provided.
Please reach the airport 3 hours before the departure of the flight. IRCTC will not responsible for missing of flights by the guest.
Kindly reconfirm the departure terminal and the flight schedule from the airline before leaving for the airport.
Web check in is not possible in our group packages.
Transfers and Sightseeing tours are on SIC (seat in coach) / shared basis by A/C vehicle.
Arrival / departure transfers & sightseeing tours shall be provided as per schedule. However this may require you to wait at the airport for short duration until all the guests arriving at that time exit the airport.
The request for an adjacent or an adjoining room will be on subject to availability.
It is mandatory to carry the age proof of children (02 to 11 yrs) and infant (below 02yrs) as well along with other travel documents. Child above than 11 yrs shall be considered for an adult cost.
In airline no seat is provided to Infant.
Room allocation (Twin bed / Double bed) is at the discretion of the hotel. Number of meals is always corresponding to the number of nights booked. Breakfast is not provided on the day of arrival.
In hotels for an extra Adult / Child either Rollaway bed or mattress shall be provided.
For early check in and late check out the payment is to be settled directly by the guest.
Hotel has the right to claim the damages incurred by any of the guest.
The guests are requested to take care of their personal belongings carefully and avoid leaving them unattended.
The airfares and taxes are calculated as on a mentioned date and any increase in the Taxes or airfares will be borne by the customer.
For any change in Flight Timings/diversions, Flight cancellation from the airline IRCTC will not be responsible and if it further affects the Sightseeing/Itinerary client need to accommodate accordingly.
Cost of additional services availed by the guest which are not part of our package inclusions are to be settled directly at the hotel.
Buffet/Fixed meal will be provided at fixed venue decided by the hotel.
You are kindly requested to check the perfect buffet timings at the time of check in at the hotel. Once the buffet time is over the hotel might ask you to pay for your meals.
IRCTC request you that before finalizing the tour with us kindly go through the website of the hotels and read the reviews.
Package cost is calculated on lowest class Air Fare. Any increase in air fare or air port taxes has to be borne by the client.
Any Itinerary posted on the website is only a proposed holiday outline.
In case there is any change in price the same will be communicated to yourself and only after your confirmation, we will proceed further.
There will be no refund for un-utilized services.
The package Price is subject to change without prior notice.
Above tour prices are subject to change in the event of increase in hotel room rates levy by the hotel especially during peak season / holiday surcharge and major events/ fairs and convention.
Passenger should get full briefing about the tour from IRCTC before/after the booking to avoid any confusion.
IRCTC is not liable for personnel expenses, boating, porterage, theft, accidents etc.
Any other terms and conditions applied as may be decided by IRCTC at any point of time.Lunches during the tour.
Any increase in Airfare
Any increase in Airport Taxes, Fuel Surcharge, Visa fee will be payable by passenger.
Meals are preset and a choice of menu is not available
Any room service will be chargeable.
All kind of tips to drivers, guides, representative, Fuel Surcharge, etc
Any increase in rate of exchange leading to an increase in surface transportation and land arrangements which may come into effect prior to departure. The tour price is subject to increase without notice if this rate changes substantially prior to departure
Any expenses of personal nature such as laundry expenses, wines, food and drinks not in the regular menus provided by us
Anything not included in the inclusions.",
		      "name": "Best of Switzerland and Paris Ex New Delhi",
		      "telephone": "+91-9415285186"
		    }
		    </script>
			";i:5;N;}