a:6:{i:0;s:20080:"				<div class="h1"><h1>Sri Lanka'S Rich Ramayana Heritage Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.oppexholidays.com/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.oppexholidays.com/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Sri Lanka'S Rich Ramayana Heritage Tour</p>
				<br />
				
								
						<script language="javascript"> 
							function topDestinationToggle(showHideDiv, switchTextDiv) {
							var ele = document.getElementById(showHideDiv);
							var text = document.getElementById(switchTextDiv);
							if(ele.style.display == "block") {
								ele.style.display = "none";
							  text.innerHTML = "View More &#9660;";
							}
							else {
							  ele.style.display = "block";
							  text.innerHTML = "View Less &#9650;";
							}
							}
		                </script>
											<script type="text/javascript">			
					(function($){	
					  $(function(){
						$('[id^=detailslider]').each(function(){
							$(this).DG_Slider({
								auto: true, mode:'fade', pager:true, pagerType:'short',controls:true
							});
						})
				
						$('a[rel=gall]').fancybox()
					  });	
					}(jQuery))
					</script>
					
					<br />
					<div class="data">
					<table class="w100 formTable bdr0 imgWidth">
					<tr>
					<td class="p10px">
					<table class="w100 packageForm">
											<tr>
						<td class="b p5px w125px vat">Duration </td>
						<td class="p5px pl0px vat">
						5 Nights / 6 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Colombo, Kandy, Nuwara Eliya, Negombo</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Price (Starting From) </td>
						<td class="p5px pl0px vat"><span class="dif">On Request</span></td>
						</tr>
												<tr>
						<td></td>
						<td>
						<p>
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.oppexholidays.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Sri Lanka'S Rich Ramayana Heritage 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="20272"/>
						</form>
						</p>
						</td>
						</tr>
											</table>
					</td>
											<td class="p10px vat imgWidth150 w150px lh0">
						<div class="demo-wrap">
						<ul class="lsn m0px p0px" id="detailslider1">
															<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_2/37817/36865.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/37817/36865.jpg"  width="150" height="150"    alt="Sri Lanka'S Rich Ramayana Heritage Tour" title="Sri Lanka'S Rich Ramayana Heritage Tour" /></a></p></div></li>
																		<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_2/37817/36866.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/37817/36866.jpg"  width="150" height="150"    alt="Sri Lanka'S Rich Ramayana Heritage Tour" title="Sri Lanka'S Rich Ramayana Heritage Tour" /></a></p></div></li>
																		<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_2/37817/36867.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/37817/36867.jpg"  width="150" height="150"    alt="Sri Lanka'S Rich Ramayana Heritage Tour" title="Sri Lanka'S Rich Ramayana Heritage Tour" /></a></p></div></li>
																		<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_2/37817/36868.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_2/37817/36868.jpg"  width="150" height="150"    alt="Sri Lanka'S Rich Ramayana Heritage Tour" title="Sri Lanka'S Rich Ramayana Heritage Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					SRI LANKA'S RICH RAMAYANA HERITAGE<br />
Sri Lanka is the proud custodian of more than 50 Ramayana sites - from the place of Seetha Devi's captivity to the battlefields where vast armies clashed, to the groves of exotic herbs dropped by the monkey god Hanuman, to the ultimate theatre of war where Lord Rama slew Ravana, the tenheaded demon-king.<br />
People living in the areas where great events took place, remember to this day the connection of their soil to the great epic. An oath taken at the spot where Seetha Devi undertook 'Agni Pariksha' is still considered valid in village courts or gramasabhas. The colour of the soil of the ancient battlefield is still red today, and is still surrounded by lighter coloured earth. One of the encampments of Ravana, torched by Hanuman when he came looking for Seetha Devi, still has a scorched-earth look. A patch of darker soil surrounded by brown earth. Exotic alpine Himalayan species are found suddenly amidst tropical Sri Lankan vegetation, the legacy of Hanuman's heroic voyage carrying a mountain with life-restoring herbs.<br />
Incredibly, the names of places have come down to modern times unchanged. Though great social, cultural and religious changes have taken place in Sri Lanka since.<br />
The following Ramayana tour will provide you with an insight of Sri Lanka's legacy and the glorious age whose events defines and guides us to this day.Visa fees and international / domestic flights<br />
Medical Insurance.<br />
Anything not specified in the package inclusions.<br />
Meals other than specified.<br />
Entrance fees.<br />
Items of personal nature.<br />
Tipping and porterage.<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> Colombo - Kandy ( 150 Km )
								</p>
								<p class="aj">After your arrival at the Bandaranayake International Airport you will be welcomed by a representative of Sri Holidays and start the transfer to your hotel in Kandy.<br />
In the afternoon visit to the TEMPLE OF THE SACRED TOOTH RELIC. It was built within the royal<br />
palace complex and houses the only surviving relic of Buddha, a tooth, which is venerated by Buddhists from all over the world. The relic has played an important role in the local politics since ancient times, it's believed that whoever holds the relic holds the governance of the country, which caused the ancient kings to protect it with great effort. Kandy was the capital of the Sinhalese Kings from 1592 to 1815, fortified by the terrain of the mountains and the difficult approach. The city is a world heritage site declared by UNESCO, in part due to the Temple of the Tooth. Monks of the two chapters of Malwatte and Asgiriya conduct daily ritual worship in the inner chamber of the temple, in annual rotation. They conduct these services three times a day: at dawn, at noon and in the evening. On Wednesdays there is a symbolic bathing of the Sacred Relic with an herbal preparation made from scented water and flagrant flowers, called Nanumura Mangallaya. This holy water is believed to contain healing powers and is distributed among those present. There are special religious programs conducted in the temple on every Full Moon Poya day where large numbers participate. Apart from these daily, weekly and monthly ceremonies, there are four major ceremonies held every year. They are Aluth Sahal Mangallaya, Avurudu Mangallaya, Esala Mangallaya and Karthika Mangallaya. Of these, the most important is the Esala Mangallaya.<br />
Overnight at a selected hotel in Kandy.</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> Kandy - Nuwara Eliya ( 90 Km )
								</p>
								<p class="aj">After breakfast you will be leaving for Nuwara Eliya. On the way visit to SRI BAKTHA HANUMAN TEMPLE – RAMBODA. Ramboda is an area, where the forces of Rama's gathered to fight King Ravana. The hills of Ramboda are also believed where Hanuman was searching for Sita Devi. The Chinmaya mission of Sri Lanka has built an Anjaneyar Temple with Hanuman as the presiding deity. This temple is called Sri Baktha Hanuman Temple and the image of Lord Hanuman here is 16 Feet tall. In the afternoon visit to GAYATHRI PEEDAM - NUWARA ELIYA. Gayathripeedam is believed to be the place from where King Ravana's son Meghanath propitiated Lord Shiva with penance and pooja's and in turn was granted super natural powers by Lord Shiva. The Gayathri Cathedral also known as Sri-Lanka Theeswarar Temple, situated in an area known for Swamiji, also fondly identified as Sri-Nagar, which means the Metropolis of Prosperity.<br />
Nuwara Eliya a colonial town also known as the 'Little England' to the outside world and the Islanders for its mild, almost European climate. The former British hill station is the heart of Sri Lanka's tea country, producing 50% of the world's finest teas. A truly impressive site surrounded by rolling mountains carpeted of velvety green tea plantations, interspersed with gushing streams and tumbling waterfalls. Located 1890 meters above sea level, the mild climate and misty glens of Nuwara Eliya reminds one of the British Isles. Nuwara Eliya is also the location for one of the best 18 hole golf courses in Asia and Sri Lanka's highest mountain Pidurutalagala (8282 ft).<br />
Overnight at a selected hotel in Nuwara Eliya.</p>					
									<p><b>Meals : </b> Breakfast & 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> Nuwara Eliya - Ella - Nuwara Eliya ( 70 Km One Way )
								</p>
								<p class="aj">In the morning you will be leaving for Ella - another imortant Ramayana location. First a visit to the HAKGALA BOTANICAL GARDEN. Hakgala Garden is the exotic pleasure garden where king Ravana kept the depressed Sita, insisting that she marry him. It was here where the heartwarming meeting took place between her and Hanuman, who brought her Rama’s ring with the news that Rama was looking for her. He offered to carry her back but she refused saying it would be an insult to Rama’s honour if he did so. Part of this majestic garden still exists. It is also said that Hanuman nearly destroyed it in order to prove to Ravana of the forces against him.<br />
Visit to the SEETHA AMMAN TEMPLE. The stream that runs from the hill, catered to the needs of Sita Devi during her stay at Ashok Vatika. She is said to have bathed in this stream. About a century ago three idols were discovered in the stream, one of which was that of Sita. It is believed that the idols have been worshipped at this spot for centuries. Now there is temple for Lord Rama, Sita Devi, Luxshmana, and Hanuman by the side of this stream. It is interesting to note that footprints akin to Lord Hanuman's are found by this river and some are of small size and some are of large size, which tells us of the immense powers of Hanuman transforming himself into any size. Afternoon visit to the DIVURUMPOLA TEMPLE. Divurumpola means a ‘place of oath’. This is the place where Sita underwent the “Agni” trial. She emerged unscathed and proved her innocence and purity. The message of Rama’s victory over Ravana was sent to Sita. After a bath and adorned with jewels she was taken on a palanquin before Rama. Meeting her husband after such a long time she was overcome with emotion, but Rama seemed lost in thought. At length he spoke, "I have killed my enemy. I have done my duty as a true king. But you have lived for a year in the enemy’s abode. It is not proper I take you back now." Sita was shocked. "You have broken my heart" she said, "only the uncultured speak like this". Have you forgotten the noble family I come from? Is it my fault Ravana carried me off by force? All the time, my mind, my heart, and soul were fixed on you alone, my lord! She turned to Lakshmana and said with tears streaming from her eyes, "prepare for me a fire. That is the only remedy for this sorrow of mine." Lakshmana in suppressed anger, looked at Rama’s face, but there was no softening, he lighted a big fire. Sita reverently went round her husband and approached the blazing fire. Joining her palms in salutation, she said, "if I am pure, of fire, protect me." With these words she jumped into the flames. Then arose from out of the flames Agni, the firegod, whom she had invoked. He lifted Sita from the flames unharmed, and presented her to Rama. "Don’t I know that she is spotless and pure at heart?" cried Rama, standing up to receive her. It’s for the sake of the world that I made her go through this ordeal of fire, so that the truth may be known to all." Today the temple is revered for the oath taken by Sita Devi and even the legal system permits and accepts the swearing done at this temple while settling disputes between parties. Visit to the RAWANA ELLA CAVES & RAWANA FALLS. Rawana Ella Cave is where Ravana was hiding Sita and is located at the massive Ella Falls; a breathtaking 1080 feet high waterfall that cascades into several falls. The rocky undergoes of the waterfall is Khondalite, a kind of limestone which undergoes faster decay as hard gneiss or granite. This has resulted in many caves being formed near the falls. King Ravana is said to have lived in one of the caves above the waterfall. A nearby pool bored out of the rock by the gushing waters is where Sita is said to have bathed Ravana. Late afternoon return to Nuwara Eliya.<br />
Overnight at a selected hotel in Nuwara Eliya.</p>					
									<p><b>Meals : </b> Breakfast & 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> Nuwara Eliya - Colombo - Negombo ( 240 Km )
								</p>
								<p class="aj">On our way to Colombo we will visit KELANIYA. After King Ravana’s death, Vibeeshana was crowned as King of Lanka by Lakshmana at Kelaniya. There are murals enshrined outside the Buddhist temple depicting the ceremony. The Kelani River is mentioned in the Valmiki Ramayana and Vibeeshana's Palace was said to be on the banks of this river. The reason Lakshmana crowned Vibeeshana was because Rama had to return to India as he had to continue his self-exile of 14 years to honour the commitment to his father, King Dasarath of Ajodhya. King Vibeeshana was considered a fair king, as he supported Rama against his own brother’s injustice. Many devotees that visit King Vibeeshana’s shrine pray to him asking his intervention to a fair recourse to their problems.<br />
In the afternoon your are free to explore the Colombo Galle Face Green or Negombo's famous beach.<br />
Overnight at a selected hotel in Negombo.</p>					
									<p><b>Meals : </b> Breakfast & 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> Negombo - Munneswaram – Negombo ( 80 Km One Way )Negombo - Munneswaram - Negombo ( 80 Km One Way
								</p>
								<p class="aj">Visit to MUNNESWARAM. It is believed that Munneswaram predates the Ramayana and a temple dedicated to Lord Shiva was located here. Munneswaram means the first temple for Shiva (Munnu + Easwaran). A Shiva Lingam was already here when Lord Rama visited the place. After his victorious battle Lord Rama left for Ayodhya with Sita in one of King Ravana's Vimanas. He felt he was being followed by Bramhaasthi Dosham (a malevolent black shadow) as he had killed King Ravana, who was a Brahmin. When the Vimana was passing over Munneswaram, he felt the vimana vibrating, and realized the "Brahmaasthi Dosham" was not following him at this particular point. He stopped the vimana at this juncture and asked God Shiva for a remedy. God Shiva blessed Lord Rama and advised installing and praying at the four lingams at Manavari, Thiru Koneshwaram, Thiru Ketheshwaram and Rameshwaram in India, as the only remedy to get rid of the dosham.<br />
Later visit to MANAVARI. Manavari is the first place where Lord Rama installed and prayed at the Siva lingam after the end of the war with King Ravana. To date this lingam is called as Ramalinga Shivan. Rameshwaram is the only other lingam in the world named after Lord Rama.<br />
Late afternoon you will be returning to Negombo and can relax at the hotel/beach.<br />
Overnight at a selected hotel in Negombo.</p>					
									<p><b>Meals : </b> Breakfast & 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> Departure
								</p>
								<p class="aj">Tour End</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>
															</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Visa fees and international / domestic flights</li><li>
Medical Insurance.</li><li>
Anything not specified in the package inclusions.</li><li>
Meals other than specified.</li><li>
Entrance fees.</li><li>
Items of personal nature.</li><li>
Tipping and porterage.</li></ul><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. ~^#^~												</div>
												
						<div class="ac mb10px">
						<form name="frmpackagedetail" id="frmpackagedetail" method="post" action="http://www.oppexholidays.com/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Sri Lanka'S Rich Ramayana Heritage 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="20272"/>
						</form>
						</div>
						
						";i:1;s:78:"Book Sri Lanka'S Rich Ramayana Heritage Tour - 5 Nights / 6 Days Tour Packages";i:2;s:164:"book sri lanka's rich ramayana heritage tour - 5 nights / 6 days tour packages, forts and palaces tour packages, colombo, kandy, nuwara eliya, negombo tour packages";i:3;s:240:"Oppex Travels & Tours ( a Division of Oppex Freight Systems offers Sri Lanka'S Rich Ramayana Heritage Tour - 5 Nights / 6 Days tour package, budget Forts and Palaces tour packages for Colombo, Kandy, Nuwara Eliya, Negombo at exciting price.";i:4;s:2047:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Colombo, Kandy, Nuwara Eliya, Negombo"        
		                 },
		      "description": "SRI LANKA'S RICH RAMAYANA HERITAGE
Sri Lanka is the proud custodian of more than 50 Ramayana sites - from the place of Seetha Devi's captivity to the battlefields where vast armies clashed, to the groves of exotic herbs dropped by the monkey god Hanuman, to the ultimate theatre of war where Lord Rama slew Ravana, the tenheaded demon-king.
People living in the areas where great events took place, remember to this day the connection of their soil to the great epic. An oath taken at the spot where Seetha Devi undertook 'Agni Pariksha' is still considered valid in village courts or gramasabhas. The colour of the soil of the ancient battlefield is still red today, and is still surrounded by lighter coloured earth. One of the encampments of Ravana, torched by Hanuman when he came looking for Seetha Devi, still has a scorched-earth look. A patch of darker soil surrounded by brown earth. Exotic alpine Himalayan species are found suddenly amidst tropical Sri Lankan vegetation, the legacy of Hanuman's heroic voyage carrying a mountain with life-restoring herbs.
Incredibly, the names of places have come down to modern times unchanged. Though great social, cultural and religious changes have taken place in Sri Lanka since.
The following Ramayana tour will provide you with an insight of Sri Lanka's legacy and the glorious age whose events defines and guides us to this day.Visa fees and international / domestic flights
Medical Insurance.
Anything not specified in the package inclusions.
Meals other than specified.
Entrance fees.
Items of personal nature.
Tipping and porterage.",
		      "name": "Sri Lanka'S Rich Ramayana Heritage Tour",
		      "telephone": "+91-9821321975"
		    }
		    </script>
			";i:5;N;}