a:6:{i:0;s:32194:"				<div class="h1"><h1>American Grandeur Ex Chennai Tour</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>American Grandeur Ex Chennai 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">Tour Code </td>
						<td class="p5px pl0px vat">AMEZING AMERICA</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						11 Nights / 12 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">New York, Las Vegas, Los Angeles, San Francisco, Niagara, Williamsport, Hershey, Washington D.C, Philadelphia</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat">
						INR 285000 Per Person						</td>
						</tr>
												<tr>
						<td class="b p5px dif w125px vat">Special Offer </td>
						<td class="p5px pl0px dif vat">TOUR HIGHLIGHTS: <br />
A complete all-inclusive tour at an honest price with maximum quality sightseeing and minimum travelling time.<br />
Stay in conveniently located quality hotels.<br />
Enjoy daily breakfast. Hot delicious unlimited Indian / vegetarian / non-vegetarian meals included.<br />
A relaxed tour with time for shopping.<br />
Visit the famed Santa Monica Pier Stay 02 nights in San Francisco - The Bay City. Embark onboard the Bay Cruise for San Francisco's original sightseeing adventure.<br />
See the charming city of San Francisco on your guided tour with a photo stop at the Golden Gate Bridge.<br />
Stay 02 nights in the 'City of Stars' - Los Angeles.<br />
Enjoy a city tour of Los Angeles. Join the biggest stars of all time at Hollywood's famous 'Universal Studios'.<br />
Stay 02 nights in the Gambling Capital of the world - Las Vegas. Breathtaking Helicopter Ride at night in Las Vegas. Enjoy fantastic views of the majestic Grand Canyon on the highlights tour by air.<br />
Enjoy a drive down the Las Vegas strip in a limousine. Las Vegas by night with Fremont Street experience.<br />
A thrilling boat-ride aboard 'The Maid of the Mist'. Experience the 'Cave of the Winds'.<br />
See the gorgeous spectacle of the Niagara Falls lit-up at night.<br />
Visit the most popular American chocolate outlet - Hershey's Chocolate World. Stay 01 night in Niagara.<br />
The Capital of USA Enjoy a guided city tour of Washington, D.C. Visit the famous Smithsonian National Museum of Natural History in Washington, D.C. Stay 01 night in Harrisburg.<br />
Stay 02 nights in New York - The City that never sleeps. Enjoy the action of New York on your guided city tour. Visit the Dazzling Times Square by night.<br />
Enjoy a boat cruise to the Statue of Liberty for a close-up view.<br />
Catch a breath-taking view of New York City from the Observation deck of One World Trade Center Stay 01 night in Washington, D.C.<br />
Professional, friendly, multi-lingual and experienced Indian Tour Managers travelling with you throughout your tour in Normal insurance charges for the duration of the tour are included in the tour price.<br />
Things to Note USA. Visit all the major cities in 12 days: San Francisco, Los Angeles Las Vegas ,Niagara, Williamsport, Hershey, Washington D.C, Philadelphia & New York</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="American Grandeur Ex Chennai 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="58669"/>
						</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/110938.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_9/257644/110938.jpg"  width="150" height="150"    alt="American Grandeur Ex Chennai Tour" title="American Grandeur Ex Chennai Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					Europe:- The United States of America (USA), commonly referred to as the United States (U.S.) or America, is a federal republic[19][20] composed of 50 states, a federal district, five major territories and various possessions.[fn 1][fn 2] The 48 contiguous states and Washington, D.C., are in central North America between Canada and Mexico. The state of Alaska is in the northwestern part of North America and the state of Hawaii is an archipelago in the mid-Pacific. The territories are scattered about the Pacific Ocean and the Caribbean Sea. At 3.8 million square miles (9.842 million km2)[18] and with over 320 million people, the country is the world's third or fourth-largest by total area[fn 3] and the third most populous. It is one of the world's most ethnically diverse and multicultural nations, the product of large-scale immigration from many countries.[26] The geography and climate of the United States are also extremely diverse, and the country is home to a wide variety of wildlife.<br />
Traveling Mode - By Flight<br />
Station/Departure Time - Chennai airport at 21:35 hrs.<br />
Class - Comfort<br />
Frequency - 29-Jun-2016<br />
Group Size - 24<br />
<br />
Accommodation:<br />
02 nights in San Francisco.<br />
02 nights in Los Angeles.<br />
02 nights in Las Vegas.<br />
01 night in Niagara.<br />
01 night in Williamsport.<br />
01 night in Washington DC.<br />
02 nights in New York.<br />
<br />
Airfare & Taxes: <br />
Onward And Return Air Ticket By M/S. Etihad Air Lines.<br />
All Local Taxes And Services.<br />
<br />
Medical Insurance :<br />
Normal Insurance Charges For The Duration Of The Tour Are Included In The Tour Price. However, Any Passenger Above The Age Of 60 Years And Those Who Wish To Extend Their Stay Will Be Required To Pay Additional Charges.<br />
<br />
Note: <br />
Documents Required For Us Visa:-<br />
<br />
Mandatory Documents:<br />
Passport Valid For A Minimum Of 6 Months From The Date Of Travel (Include Old Passports).<br />
Us Appointment Confirmation.<br />
Ds 160 Confirmation.<br />
2 Photographs 50 X 50 Mm With Glossy Finish And White Back Ground.<br />
<br />
If Salaried:- <br />
Copies Income Tax Returns For Last 3 Years (Saral Form Or Form 16).<br />
Original Bank Statements For The Last 6 Months With Adequate Balance Well Over Your Tour Cost (Required 01 Set With Bank Seal And Signature In All Pages).<br />
Copies Of Investments Like Fixed Deposits, Nsc, Ppf (Postal Provident Fund) Mis (Monthly Income Scheme), Govt Bonds Etc.<br />
Salary Slip Or Certificate For The Last 6 Months.<br />
Original Leave Authorization From Employer (Noc For Govt Employees).<br />
If Self Employed<br />
Copies Of Income Tax Returns For Last 3 Years (Saral Form, Personal As Well As From Your Company).<br />
Original Bank Passbook Or Statements For The Last 6 Months With Adequate Balance Well Over Your Tour Cost, Personal As Well As From Your Company (Required 02 Set With Bank Seal And Signature In All Pages).<br />
Copies Of Investments Like Fixed Deposits, Nsc, Ppf (Postal Provident Fund) Mis (Monthly Income Scheme), Govt Bonds Etc.<br />
Balance Sheet Of Your Company For The Last 3 Years.<br />
Copies Of The Sale Deeds Of Immovable Properties.<br />
Company Registration Certificate + Partnership Deed Or Memorandum Of Association.<br />
Noc Letter From Partner / Director + Pan Card Copy.<br />
<br />
If Retired<br />
Copies Income Tax Returns For Last 3 Years (Saral Form).<br />
Original Bank Passbook Or Statements For The Last 6 Months With Adequate Balance Well Over Your Tour Cost (Required 02 Set With Bank Seal And Signature In All Pages).<br />
Copies Of Investments Fixed Deposits, Nsc, Ppf (Postal Provident Fund) Mis (Monthly Income Scheme), Govt Bonds Etc.<br />
Pension Order, Retirement Order From Your Last Employer.<br />
<br />
If Student<br />
School / College Bona Fide Certificate.<br />
<br />
Other Special Categories: <br />
<br />
Passenger Below 20 Years Not Accompanied By Parents: <br />
Noc From Parents On Rs 20 Stamp Paper Or On The Business Letter Head Of The Parent<br />
(Please Check With Our Staff For The Format).<br />
<br />
Honeymoon Couple <br />
Original Marriage Certificate<br />
Or<br />
Wedding Invitation Card + Noc From The Bride’S Parents Along With A Proof Of Signature Identification Of The Bride’S Parent. Eg Passport Copies Of The Bride'S Parent.<br />
<br />
When Spouse Name Not Mentioned In The Passport : <br />
Original Marriage Certificate<br />
Or<br />
Wedding Invitation Card + Noc From The Bride’S Parents Along With A Proof Of Signature Identification Of The Bride’S Parent. Eg Passport Copies Of The Bride'S Parents. <br />
Photo Specification For United Kingdom & Schengen Visa.TOUR HIGHLIGHTS: <br />
A complete all-inclusive tour at an honest price with maximum quality sightseeing and minimum travelling time.<br />
Stay in conveniently located quality hotels.<br />
Enjoy daily breakfast. Hot delicious unlimited Indian / vegetarian / non-vegetarian meals included.<br />
A relaxed tour with time for shopping.<br />
Visit the famed Santa Monica Pier Stay 02 nights in San Francisco - The Bay City. Embark onboard the Bay Cruise for San Francisco's original sightseeing adventure.<br />
See the charming city of San Francisco on your guided tour with a photo stop at the Golden Gate Bridge.<br />
Stay 02 nights in the 'City of Stars' - Los Angeles.<br />
Enjoy a city tour of Los Angeles. Join the biggest stars of all time at Hollywood's famous 'Universal Studios'.<br />
Stay 02 nights in the Gambling Capital of the world - Las Vegas. Breathtaking Helicopter Ride at night in Las Vegas. Enjoy fantastic views of the majestic Grand Canyon on the highlights tour by air.<br />
Enjoy a drive down the Las Vegas strip in a limousine. Las Vegas by night with Fremont Street experience.<br />
A thrilling boat-ride aboard 'The Maid of the Mist'. Experience the 'Cave of the Winds'.<br />
See the gorgeous spectacle of the Niagara Falls lit-up at night.<br />
Visit the most popular American chocolate outlet - Hershey's Chocolate World. Stay 01 night in Niagara.<br />
The Capital of USA Enjoy a guided city tour of Washington, D.C. Visit the famous Smithsonian National Museum of Natural History in Washington, D.C. Stay 01 night in Harrisburg.<br />
Stay 02 nights in New York - The City that never sleeps. Enjoy the action of New York on your guided city tour. Visit the Dazzling Times Square by night.<br />
Enjoy a boat cruise to the Statue of Liberty for a close-up view.<br />
Catch a breath-taking view of New York City from the Observation deck of One World Trade Center Stay 01 night in Washington, D.C.<br />
Professional, friendly, multi-lingual and experienced Indian Tour Managers travelling with you throughout your tour in Normal insurance charges for the duration of the tour are included in the tour price.<br />
Things to Note USA. Visit all the major cities in 12 days: San Francisco, Los Angeles Las Vegas ,Niagara, Williamsport, Hershey, Washington D.C, Philadelphia & New YorkAny increase in Airfare.<br />
Any increase in Airport Taxes, Fuel Surcharge.<br />
Meals are preset & Choice of menu is not available.<br />
All Kinds of tips to drivers, guides, representative etc.<br />
Any expenses of personal nature such a laundry expenses, wine, mineral water, food and drinks other than mentioned in the regular menu.<br />
Any services not specified in the inclusion Activities of any kind are excluded in the package.<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> Chennai - San Francisco
								</p>
								<p class="aj">Board your flight to San Francisco.<br />
Bon voyage ! Today you are off on your American Grandeur tour with IRCTC as you board your flight to San Francisco. On arrival, your Local Representative will be waiting outside the customs area to welcome you and take you to your hotel (Check-in time is after 1500 hrs). <br />
<br />
Overnight at the hotel in San Francisco.</p>					
									<p><b>Meals : </b> (Dinner)</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> San Francisco
								</p>
								<p class="aj">Guided City Tour of San Francisco<br />
Bay Cruise in San Francisco <br />
Today, we check out and proceed on a guided city tour of San Francisco, as your guide points out landmarks and shares the history of San Francisco, See the famous Golden Gate Bridge - the world’s longest single span suspension bridge, a symbol of San Francisco. Visit The Twin Peaks, which offer a spectacular view of downtown San Francisco. See Telegraph Hill, Ghirardelli Square and Fisherman’s Wharf. We also walk on the Lombard Street in San Francisco which is one of America’s crooked streets. Your visit to San Francisco is not complete without a cruise on the San Francisco Bay, the largest inlet on the Californian Coast. Enjoy the great sights, as your cruise takes us under the Golden Gate Bridge, around Alcatraz island and past the city skyline. <br />
<br />
Overnight at the hotel in San Francisco.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch & Dinner)</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> San Francisco - Los Angels
								</p>
								<p class="aj">Visit to Santa Monica Beach<br />
Drive to Los Angeles <br />
Today, we check out of the hotel and take you to visit Santa Monica Beach where you will enjoy a pleasant Mediterranean climate. Later, we sit back in our air conditioned coach and enjoy our drive to Los Angeles. On arrival, we check into the hotel. The evening is free to explore Hollywood city on your own. <br />
<br />
Overnight at the hotel in Los Angeles.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch & Dinner)</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> Los Angeles
								</p>
								<p class="aj">Visit to Universal Studios Hollywood SM<br />
Panoramic Orientation Tour of Los Angeles <br />
Today, we join the Hollywood stars at the famous Universal Studios. Relax in the comfort of a tram car as it takes you behind the scenes to show you how Hollywood makes movies. Experience the first-ever mega-attraction based on the blockbuster TV series, The Simpsons. Featuring the show’s classic humour and many of its instantly recognizable characters - all voiced by the original actors Join Shrek, Donkey and Princess Fiona in Shrek 4D, an all new adventure which picks up where the Oscar winning movie ‘Shrek’ left off and puts you inside the action! Later, we take you on an panoramic orientation tour of Los Angeles. Enjoy some time at the Hollywood Boulevard where you see the Hollywood Walk of Fame, The Dolby Theatre - where the Oscars are held, the TCL Chinese Theatres (formerly the Manns Chinese Theatre) and see the handprints and footprints of famous Hollywood Stars. Also drive down the famous Sunset Boulevard and Beverly Hills. <br />
<br />
Overnight at the hotel in Los Angeles.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch & Dinner)</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> Los Angeles - Las Vegas
								</p>
								<p class="aj">Drive to Las Vegas Ride on High Roller<br />
Illumination Night Tour of Las Vegas<br />
<br />
Today, we check out of the hotel, sit back in our air conditioned coach and drive to Las Vegas. On arrival, we take a ride on High Roller, the world’s largest observation wheel. Located at the heart of the Las Vegas Strip, the High Roller is the focal point of the $550 million open-airshopping, dining and entertainment district. With panoramic views of the Strip, the valley and the mountains, there’s something to see from every angle. Later in the evening, enjoy the splendour of Las Vegas on the Illumination Tour of ‘Las Vegas by Night’. Watch the twinkling lights, be awed by the huge neon signs as you see the famous landmarks - New York skyline, Bellagio fountains, the Pyramid, which are some of the many facades of the different hotels along the ‘Las Vegas Strip’ as we make our way to down town Las Vegas for the Freemont Street Experience. Here you see a dazzling display on the world’s largest TV screen with over a million light bulbs covering three city blocks!.<br />
<br />
Overnight at the hotel in Las Vegas.(Breakfast, Lunch &Dinner).</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> Las Vegas
								</p>
								<p class="aj">Day Free.<br />
Suggested Excursion: Visit to the Grand Canyon.<br />
<br />
Today, enjoy exploring the Grand Canyon for once in a lifetime experience. by coach. (There’s an option of the Highlights Air Tour, the Air and Ground Tour, Air and Ground tour with Boat and Helicopter with an add-on option of Skywalk.) Experience the full depth of the beauty, colour and majesty of the ravines and cliffs as you fly over the Grand Canyon on the Air and Ground Tour. Evening is free to visit one of the many casinos that Las Vegas is world famous for. <br />
<br />
Overnight at the hotel in Las Vegas.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch & Dinner).</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> Las Vegas - Buffalo
								</p>
								<p class="aj">Fly to Buffalo<br />
Niagara by Night<br />
Today, we check out of the hotel and drive to the airport for our flight to Buffalo. On arrival, we check in to the hotel. This evening, we drive to experience the majesty and tranquillity of the splendorous Niagara Falls by night. See the Falls magically lit-up, an aweinspiring sight.<br />
<br />
Overnight at the hotel in Niagara.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch & Dinner).</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 8:</b> Niagara - Williamsport
								</p>
								<p class="aj">‘Maid of the Mist’ Boat Ride<br />
Drive to Williamsport<br />
Today, we check out and drive to Niagara Falls and experience the exhilarating force of the falls as we take the ‘Maid of the Mist’ boat ride into the heart of the mighty Horseshoe Falls. It’s a fantastic journey through crashing waters surrounded by massive rock formations. (Due to weather conditions, the ‘Maid of the Mist’ operates only from the last week of May. All tours visiting Niagara before the last week of May will take a ride on the View Mobile Tram). Later, we drive to Williamsport. <br />
<br />
Overnight at the hotel in Williamsport.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch).</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 9:</b> Williamsport - Hershey - Washington.D.C
								</p>
								<p class="aj">Visit Hershey’s Chocolate World<br />
Onto Washington DC<br />
Visit to National Air and Space Museum<br />
Guided City Tour of Washington DC<br />
Today, we check out of the hotel and drive to Hershey. On arrival, we visit the Hershey’s chocolate world. See the Cocoa beans turn into delicious chocolate right in front of your eyes. Seize this opportunity to visit the chocolate shop and take home goodies for your loved ones. Later, we drive to Washington DC. Upon arrival, we visit the National Air and Space Museum, where you get a unique opportunity of viewing aircraft models and displays like the Wright Brothers first aircraft and Lindberg’s ‘Spirit of St Louis’.<br />
Next, we proceed on a guided city tour of the majestic Capital of United Sates - Washington DC. See the Lincoln Memorial, Korean Memorial and Capitol Hill. Also see the White House, home of the US President. (Due to security reasons permission to go near or enter the White House is not available).<br />
<br />
Overnight at the hotel in Washington DC.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch &Dinner).</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 10:</b> Washington D.C - Philadelphia - New York
								</p>
								<p class="aj">Onto Philadelphia<br />
Orientation Tour of Philadelphia<br />
Onto New York<br />
Today, we check out of the hotel and drive through picturesque countryside, as we move ahead northwards from the capital of the United States to Philadelphia. We do the orientation tour of Philadelphia where we see the Liberty Bell, one of the most recognized symbols of American freedom. Historical documents and visual displays enlighten you on its history and why it has become the symbol of freedom for many. Later we drive to the Big Apple - New York. This New York hotel in Times Square puts you near attractions like Fifth Avenue shopping, Radio City Music Hall, NBC Studios and Central Park. There is time (on your own) to browse through the many shops dotting New York’s famed Times Square in the heart of the theatre district, or just stroll through the streets of central Manhattan. <br />
<br />
Overnight at the hotel in New York.</p>					
									<p><b>Meals : </b> (Breakfast, Lunch & Dinner).</p>
								</td>
								</tr>
								</table>					
								</div><div id="show_more_content" style="display:none;">
									<div class="data">
									<table class="w100 formTable bdr0 imgWidth">
									<tr>
									<td class="p10px vat">
									<p class="b large mb5px"><b class="dif">Day 11:</b> New York
									</p>
									<p class="aj">Guided City Tour of New York<br />
Visit to Liberty Island to see the Statue of Liberty<br />
Visit to the ‘Top of the Rock’ Observatory Deck at the Rockefeller Center<br />
Today, we proceed on a guided panoramic city tour of New York. See the wonderful sights of this exciting city - 5th Avenue, United Nations Building and New York’s lungs - the beautiful Central Park and much more. Later, we drive to Battery Park and take a ferry to Liberty Island to see the famous American icon of freedom - The Statue of Liberty. En route we get an opportunity to pay homage to the hundreds of innocent lives lost at what was once the World Trade Centre, now more easily recognized as Ground Zero. Later, we visit ‘Top of the Rock’ at Rockefeller Centre. At the Observatory Deck, see a different perspective of New York from 70 floors above. The 360º view of the cityscape makes the ‘Top of the Rock’ a must see.<br />
<br />
Overnight at the hotel in New York.</p>					
										<p><b>Meals : </b> (Breakfast, Lunch & Dinner).</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 12:</b> New York - Chennai
									</p>
									<p class="aj">Return Home with Wonderful Memories<br />
Today, we check-out and drive to the airport for your flight home. It’s time to say goodbye to all the new friends you have made. We hope you take back happy memories of your Holiday. We would like you to spare a few minutes of your time to write and tell us how you enjoyed your tour and any suggestions you may have for the future.</p>					
										<p><b>Meals : </b> (Breakfast, Lunch).</p>
									</td>	
									</tr>
									</table>				
									</div>					
							</div>							<p class="mt10px ac"><a class="buttonBig p5px10px dib b" id="more_button" href="javascript:topDestinationToggle('show_more_content','more_button');" >View More &#9660;</a></p>
													<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>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Any increase in Airfare.</li><li>
Any increase in Airport Taxes, Fuel Surcharge.</li><li>
Meals are preset & Choice of menu is not available.</li><li>
All Kinds of tips to drivers, guides, representative etc.</li><li>
Any expenses of personal nature such a laundry expenses, wine, mineral water, food and drinks other than mentioned in the regular menu.</li><li>
Any services not specified in the inclusion Activities of any kind are excluded in the package.</li></ul><br />
												<p class="large b mb5px dif">Specific Departure Dates :</p>Tour Date:- 29-Jun-2016<br />
Total Seats availability:- 24<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">Rate Card</p>
    	<div class="otherDetails aj">Cost per Person for the proposed tour :<br>
Advance Reservations contact IRCTC office by paying INR 50,000/- per person.</div><br>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Occupancy/Prices</td>
				<td class="headHr p5px b">Comfort Class</td>
			</tr>
			<tr>
				<td class="headVr p5px">Single Occupancy</td>
				<td class="data p5px">Rs. 3,52,000/-</td>
			</tr>
			<tr>
				<td class="headVr p5px">Double Occupancy</td>
				<td class="data p5px">Rs. 2,81,000/-</td>
			</tr>
			<tr>
				<td class="headVr p5px">Triple Occupancy</td>
				<td class="data p5px">Rs. 2,81,000/-</td>
			</tr>
			<tr>
				<td class="headVr p5px">Child With Bed ( 02-11 Years)</td>
				<td class="data p5px">Rs. 2,43,000/-</td>
			</tr>
			<tr>
				<td class="headVr p5px">Child Without Bed (02-11 Years)</td>
				<td class="data p5px">Rs. 2,29,000/-</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Meals:</p>
    	<div class="otherDetails aj">Note - 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="headHr p5px b">Category</td>
				<td class="headHr p5px b">Style</td>
				<td class="headHr p5px b">Total No.</td>
			</tr>
			<tr>
				<td class="headVr p5px">Breakfast</td>
				<td class="data p5px">Continental</td>
				<td class="data p5px">12</td>
			</tr>
			<tr>
				<td class="headVr p5px">Lunch</td>
				<td class="data p5px">Indian Veg / Non. Veg</td>
				<td class="data p5px">12</td>
			</tr>
			<tr>
				<td class="headVr p5px">Dinner</td>
				<td class="data p5px">Indian Veg / Non. Veg</td>
				<td class="data p5px">11</td>
			</tr>
		</table></div><br>
    	<p class="h dif xlarge b mb5px">Flight Details:</p>
		<div class="dynamic-data-container">
    	<table class="bdrAll" width="100%" cellpadding="5">
			<tr>
				<td class="headHr p5px b">Flight Details</td>
				<td class="headHr p5px b">Flight No.</td>
				<td class="headHr p5px b">From - Via - To</td>
				<td class="headHr p5px b">Departure</td>
				<td class="headHr p5px b">Arrival</td>
			</tr>
			<tr>
				<td class="headVr p5px">India - USA</td>
				<td class="data p5px">EY - 271/183</td>
				<td class="data p5px">MAA - AUH - SFO</td>
				<td class="data p5px">21:35 HRS</td>
				<td class="data p5px">07:25 HRS</td>
			</tr>
			<tr>
				<td class="headVr p5px">USA - India</td>
				<td class="data p5px">EY - 100/268</td>
				<td class="data p5px">JFK - AUH - MAA</td>
				<td class="data p5px">22:30 HRS</td>
				<td class="data p5px">03:50 HRS</td>
			</tr>
		</table></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="American Grandeur Ex Chennai 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="58669"/>
						</form>
						</div>
						
						";i:1;s:74:"Book American Grandeur Ex Chennai Tour - 11 Nights / 12 Days Tour Packages";i:2;s:232:"book american grandeur ex chennai tour - 11 nights / 12 days tour packages, forts and palaces tour packages, new york, las vegas, los angeles, san francisco, niagara, williamsport, hershey, washington d.c, philadelphia tour packages";i:3;s:276:"Grand India Tours & Travels offers American Grandeur Ex Chennai Tour - 11 Nights / 12 Days tour package, budget Forts and Palaces tour packages for New York, Las Vegas, Los Angeles, San Francisco, Niagara, Williamsport, Hershey, Washington D.C, Philadelphia at exciting price.";i:4;s:7542:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "New York, Las Vegas, Los Angeles, San Francisco, Niagara, Williamsport, Hershey, Washington D.C, Philadelphia"        
		                 },
		      "description": "Europe:- The United States of America (USA), commonly referred to as the United States (U.S.) or America, is a federal republic[19][20] composed of 50 states, a federal district, five major territories and various possessions.[fn 1][fn 2] The 48 contiguous states and Washington, D.C., are in central North America between Canada and Mexico. The state of Alaska is in the northwestern part of North America and the state of Hawaii is an archipelago in the mid-Pacific. The territories are scattered about the Pacific Ocean and the Caribbean Sea. At 3.8 million square miles (9.842 million km2)[18] and with over 320 million people, the country is the world's third or fourth-largest by total area[fn 3] and the third most populous. It is one of the world's most ethnically diverse and multicultural nations, the product of large-scale immigration from many countries.[26] The geography and climate of the United States are also extremely diverse, and the country is home to a wide variety of wildlife.
Traveling Mode - By Flight
Station/Departure Time - Chennai airport at 21:35 hrs.
Class - Comfort
Frequency - 29-Jun-2016
Group Size - 24

Accommodation:
02 nights in San Francisco.
02 nights in Los Angeles.
02 nights in Las Vegas.
01 night in Niagara.
01 night in Williamsport.
01 night in Washington DC.
02 nights in New York.

Airfare & Taxes: 
Onward And Return Air Ticket By M/S. Etihad Air Lines.
All Local Taxes And Services.

Medical Insurance :
Normal Insurance Charges For The Duration Of The Tour Are Included In The Tour Price. However, Any Passenger Above The Age Of 60 Years And Those Who Wish To Extend Their Stay Will Be Required To Pay Additional Charges.

Note: 
Documents Required For Us Visa:-

Mandatory Documents:
Passport Valid For A Minimum Of 6 Months From The Date Of Travel (Include Old Passports).
Us Appointment Confirmation.
Ds 160 Confirmation.
2 Photographs 50 X 50 Mm With Glossy Finish And White Back Ground.

If Salaried:- 
Copies Income Tax Returns For Last 3 Years (Saral Form Or Form 16).
Original Bank Statements For The Last 6 Months With Adequate Balance Well Over Your Tour Cost (Required 01 Set With Bank Seal And Signature In All Pages).
Copies Of Investments Like Fixed Deposits, Nsc, Ppf (Postal Provident Fund) Mis (Monthly Income Scheme), Govt Bonds Etc.
Salary Slip Or Certificate For The Last 6 Months.
Original Leave Authorization From Employer (Noc For Govt Employees).
If Self Employed
Copies Of Income Tax Returns For Last 3 Years (Saral Form, Personal As Well As From Your Company).
Original Bank Passbook Or Statements For The Last 6 Months With Adequate Balance Well Over Your Tour Cost, Personal As Well As From Your Company (Required 02 Set With Bank Seal And Signature In All Pages).
Copies Of Investments Like Fixed Deposits, Nsc, Ppf (Postal Provident Fund) Mis (Monthly Income Scheme), Govt Bonds Etc.
Balance Sheet Of Your Company For The Last 3 Years.
Copies Of The Sale Deeds Of Immovable Properties.
Company Registration Certificate + Partnership Deed Or Memorandum Of Association.
Noc Letter From Partner / Director + Pan Card Copy.

If Retired
Copies Income Tax Returns For Last 3 Years (Saral Form).
Original Bank Passbook Or Statements For The Last 6 Months With Adequate Balance Well Over Your Tour Cost (Required 02 Set With Bank Seal And Signature In All Pages).
Copies Of Investments Fixed Deposits, Nsc, Ppf (Postal Provident Fund) Mis (Monthly Income Scheme), Govt Bonds Etc.
Pension Order, Retirement Order From Your Last Employer.

If Student
School / College Bona Fide Certificate.

Other Special Categories: 

Passenger Below 20 Years Not Accompanied By Parents: 
Noc From Parents On Rs 20 Stamp Paper Or On The Business Letter Head Of The Parent
(Please Check With Our Staff For The Format).

Honeymoon Couple 
Original Marriage Certificate
Or
Wedding Invitation Card + Noc From The Bride’S Parents Along With A Proof Of Signature Identification Of The Bride’S Parent. Eg Passport Copies Of The Bride'S Parent.

When Spouse Name Not Mentioned In The Passport : 
Original Marriage Certificate
Or
Wedding Invitation Card + Noc From The Bride’S Parents Along With A Proof Of Signature Identification Of The Bride’S Parent. Eg Passport Copies Of The Bride'S Parents. 
Photo Specification For United Kingdom & Schengen Visa.TOUR HIGHLIGHTS: 
A complete all-inclusive tour at an honest price with maximum quality sightseeing and minimum travelling time.
Stay in conveniently located quality hotels.
Enjoy daily breakfast. Hot delicious unlimited Indian / vegetarian / non-vegetarian meals included.
A relaxed tour with time for shopping.
Visit the famed Santa Monica Pier Stay 02 nights in San Francisco - The Bay City. Embark onboard the Bay Cruise for San Francisco's original sightseeing adventure.
See the charming city of San Francisco on your guided tour with a photo stop at the Golden Gate Bridge.
Stay 02 nights in the 'City of Stars' - Los Angeles.
Enjoy a city tour of Los Angeles. Join the biggest stars of all time at Hollywood's famous 'Universal Studios'.
Stay 02 nights in the Gambling Capital of the world - Las Vegas. Breathtaking Helicopter Ride at night in Las Vegas. Enjoy fantastic views of the majestic Grand Canyon on the highlights tour by air.
Enjoy a drive down the Las Vegas strip in a limousine. Las Vegas by night with Fremont Street experience.
A thrilling boat-ride aboard 'The Maid of the Mist'. Experience the 'Cave of the Winds'.
See the gorgeous spectacle of the Niagara Falls lit-up at night.
Visit the most popular American chocolate outlet - Hershey's Chocolate World. Stay 01 night in Niagara.
The Capital of USA Enjoy a guided city tour of Washington, D.C. Visit the famous Smithsonian National Museum of Natural History in Washington, D.C. Stay 01 night in Harrisburg.
Stay 02 nights in New York - The City that never sleeps. Enjoy the action of New York on your guided city tour. Visit the Dazzling Times Square by night.
Enjoy a boat cruise to the Statue of Liberty for a close-up view.
Catch a breath-taking view of New York City from the Observation deck of One World Trade Center Stay 01 night in Washington, D.C.
Professional, friendly, multi-lingual and experienced Indian Tour Managers travelling with you throughout your tour in Normal insurance charges for the duration of the tour are included in the tour price.
Things to Note USA. Visit all the major cities in 12 days: San Francisco, Los Angeles Las Vegas ,Niagara, Williamsport, Hershey, Washington D.C, Philadelphia & New YorkAny increase in Airfare.
Any increase in Airport Taxes, Fuel Surcharge.
Meals are preset & Choice of menu is not available.
All Kinds of tips to drivers, guides, representative etc.
Any expenses of personal nature such a laundry expenses, wine, mineral water, food and drinks other than mentioned in the regular menu.
Any services not specified in the inclusion Activities of any kind are excluded in the package.",
		      "name": "American Grandeur Ex Chennai Tour",
		      "telephone": "+91-9415285186"
		    }
		    </script>
			";i:5;N;}