a:6:{i:0;s:33241:"				<div class="h1"><h1>Kashmir Great Lakes Trek Tour</h1></div>
				<p class="breadcrumb ar uu small"><a href="http://www.rapidactionexpedition.in/" title="Home">Home</a> 
				
									<b class="ffv p2px">&rsaquo;</b><a href="http://www.rapidactionexpedition.in/tour-packages.htm" title="Tour Packages">Tour Packages</a>  			
									
				<b class="ffv p2px">&rsaquo;</b>Kashmir Great Lakes Trek 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">
						7 Nights / 8 Days 
						</td>
						</tr>
												<tr>
						<td class="b p5px w125px vat">Destination Covered </td>
						<td class="p5px pl0px vat">Srinagar, Sonamarg</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.rapidactionexpedition.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Kashmir Great Lakes Trek 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="100499"/>
						</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_15/446641/169002.jpg"><img src="https://ttw.wlimg.com/package-images/photo-small/dir_15/446641/169002.jpg"  height="150"  width="150"    alt="Kashmir Great Lakes Trek Tour" title="Kashmir Great Lakes Trek Tour" /></a></p></div></li>
															</ul>
						</div>
						</td>
											</tr>
					</table>
					</div>
					<br />
					
					The Kashmir Great Lakes Trek is in no need of an introductory treatise. It presents the proem in itself. You can draw a preface of it by just hearing its name. Kashmir is a wonderful place and if you are on a himalayan trek you are bound to taste the natural beauty and adventure. The trek to the Kashmir Great Lakes Trek offers a lifetime experience of vintage memories that are so wonderfully tiring. The thundering silence of the Kashmir lakes and its virgin beauty is spell bound. Apart from the lakes, even the barren milky snow clad mountains stand out in might and proud.<br />
The location of this trek, as obvious, is Kashmir, also known as the paradise of the earth. The trek duration calculates around 7-9 days and this trek is often graded as moderate in regards to the trekking challenges. The elevation circles around 13000 feet and the distance paths approximately 63 kms. On such a fulfilling trek you will learn so much learn about yourself- in a trifecta – physically, mentally and emotionally. For a trekker, nothing can replace and prepare him for those paramount and conflicting emotions that whether his body will take so much of strain and whether he will make it or not. But the joy on reaching the destination is obvious. This trek will always be happy and a cherishing trek for the trekkers that comes in handy with a few preparations.<br />
As the trek to the Kashmir Great Lakes Trek demands physical fitness, you must take good care of your health, shape yourself well and be fit and fine. Trekkers can train themselves by working out regularly in gym along with running, walking on incline, cycling, cross-training and stretching on a daily basis. Along with physical health mental fitness is important equally.<br />
Coming to the details of the trek, it generally starts from almost 3 kms out of Sonamarg, on the Srinagar road. You can find few dhabbas on your way. It's better to the trekkers to pick up short eats here for the next trace of a dwelling place will be at Naranag that would be probably mark the end of the track.<br />
A few of the trail and the trek enters a green meadow, overlooking the Sonamarg town. At the top of the meadows trekkers reach the starting line of Maple and Pine trees. What follows is a lovey-dovey deep dense forest of Maple trees. Such an experience has always been unique to this trek in India.<br />
You will always be amongst the meadows throughout this trek. The best time to enjoy the Kashmir Great Lakes trek is in between the June and September as the greenery and the blooming flowers are at their best during this calendar period. It's so that a beginner in trekking can also join this trek.<br />
Trailing through the Maple trees uphill, trekkers can enjoy the crystal clear view of the nearby villages downhill and especially the Sonamarg village. Every bit of nature nestles to make a wonderful picture. From here the trail slopes down into yet another meadow lined by the Silver Birch trees and a few shepherd huts. Massively tiny brooks struggling through the meadows and snowy peaks of small mountains mark the land of Shekdur. Shekdur is the only camp site with trees on this trek. It is therefore an add-on in your clicks. The sun rays piercing through the forest, that comes on your way, on further trailing, makes it a nice show of dark and light. Further the trail climbs back into a river valley which is the beginning of Nichanai. You have entered into a wide valley encompassed by the peaks.<br />
After crossing a tunnel-like Nichnai pass followed up by the miles spreading meadow and the cascading waterfall with the icy cold composition of two atoms of Hydrogen and one atom of Oxygen, comes the Vishansar Lake. The first impression that the lake imposes upon the trekker is that of its volume and surrounding provided by the four mountains. It is been followed up by the Kishansar Lake which is only at a distance of 1.2 kms. It has a big meadow stretching by its side. The trail follows up through a ridge. You can see the loveliest view of the two gone-by lakes together from the Gadsar pass which is the highest point of this trek.<br />
Then the time comes to descend. On the way back, the eye captures the view of Yamsir Lake, the nameless lake and the Gadsar Lake which are all connected by all stream. Further you will come to a place called Maengandob where few deep craters are found. The landscape ahead is magnificent for you get to visit Satsar Lakes-collection of seven Lakes and further the twin lakes among which the bigger is the Gangabal and the other one to arrive is Nundkol. On your last destination two Naranag, you are greeted with awe-inspiring glaciers, meadows as well as mountain peaks.<br />
The trek to the Kashmir Great Lakes Trek will provide to the trekkers a perfect flavour of all hues of terrain- innumerable meadows, snow clad glaciers and pinnacles, passes, rocky barren lands, struggling streams. The trail to the Great Lakes is worth trekking. It does justice to all the expectations of a trekker. No individual will ever undergo but this trek will make you undergo. It is a path to heaven and its virgin serenity.<br />
While trekking, trekkers must be equipped with the necessary equipments. Apart from the professional trekking gear, stuffs inclusive of trekking shoes, trekking pole are important specifically. Trekkers must never compromise with their body requirements. It's better to understand your body need and not going by the choice of some other fella. The trek to the Kashmir Great Lakes is not a child's game but even a child of ten years can go on this trek. The luggage or the carry bag should be as light as possible. It will be in your comfort.Transport from Srinagar to Sonamarg and Narnag to Srinagar<br />
Hotel Stay in Srinagar.<br />
Food during the transit.<br />
Insurance.<br />
Mules or porter to carry personal luggage.<br />
Anything not specifically mentioned under the head.<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 Srinagar, Drive to Sonamarg
								</p>
								<p class="aj">Depart to Sonamarg in the afternoon. It is 3 hrs drive from Srinagar.</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> Sonamarg (7,800ft) to Nichnai (11,500ft) via Shekdur
								</p>
								<p class="aj">3 hour ascent followed by 1 hour descent and finally a gentle ascent to Nichnai (6 hours, 9kms)<br />
The trek starts 3 kms out of Sonamarg, on the Srinagar road. Exactly at the 3 km mark, spot a lone Dhaba on the right. The place also sells packaged water, biscuits etc and is your last place to pick up short eats. The next trace of dwelling civilization is only at Naranag at the end of the trek.<br />
A jeep track diverts to the right off the main road at the shop. The track goes down to the level of the Sindh river flows in between the mud track and the main road. The trekking trail starts along the track but quickly diverts higher up. 10 minutes into the trek, the trail bends left and enters a green meadow. The meadow directly overlooks the Sonamarg town. In half an hour you are at the top of the meadow where Maple and Pine trees start. At the tree line, the trail quickly descends to a tiny brook and then climbs again. What follows next is a lovely dense forest of Maple trees. Walking on the green bed of grass amidst the Maples is an experience unique to Kashmir in India.<br />
For the next hour and a half, the trail winds up through the Maple trees. Stick to the trail heading uphill as the ones going down head to some of the nearby villages. The trees give way to clearings in between. Turn around and see the view of the Sonamarg valley which gets better and fuller as you gain height. The Maple forest ends at the top of the ridge and the other side a meadow gently slopes down. Spend a few moments at the ridge taking in the views of the Sonamarg and its neighboring valley. The streams, the meadows, the pines and the town nestled make a wonderful picture. The climb is now over and the trail slopes down into a meadow. The meadow is lined on the left by Silver Birch trees and a few shepherd huts. The carpet of green rolls down from the trees to the end of the 40ft wide meadow. Small brooks which cross the meadow serve as water sources. On the right are small peaks with snow powdered on top of them. This is Shekdur. If you plan to have a short days trek on day one, this is where you pitch your tents for the day. It takes an average trekker about 2 1/2 hours to reach the meadow from the road head and add another half an hour if you decide to break the days trek at the end of the meadow.<br />
Shekdur is a beautiful campsite surrounded by Bhoj trees. This is the only campsite with trees on this trek and therefore adds a good variety to your moments and photographs. If you have started from Srinagar in the morning, make Shekdur your first camp. The next campsite Nichnai is atleast 2 more hours away.<br />
If you started from Sonamarg, Shekdur, just three hours into the trek is too early to camp. Have lunch at the meadows and move ahead to Nichnai. The meadow of Shekdur stretches for half an hour. The gentle descent on the meadow ends in a forest of Bhoj or Silver Birch. Take the trail that goes in the middle of the forest and continue to descend gently. Watch out for the sun rays making their way in between the thick foliage making it a nice show of light and dark.<br />
In 45 minutes, you reach the end of the Birch trees and the trail goes down and climbs back into a river valley. The river valley is the beginning of Nichanai. The trail now is along the right bank of the river going upstream. Look behind to see snow clad peaks from Sonamarg valley. You are now in wide valley but enclosed by mountains on either side. The river, which joins the Sindh eventually flows in speed through the valley. The first 30 minutes is over rocks and your mules will walk very slowly over here.<br />
An hour into the river valley green patches devoid of rocks open up. The river valley widens and you can see the green meadow widening in between the two mountain ranges. Far ahead lie triangular twin snow clad peaks. Choose a flat ground to pitch tents and end the first days trek.</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> Nichnai (11,500ft) to Vishansar lake (12,00ft)
								</p>
								<p class="aj">Medium climb to Nichnai pass 13,500ft. Small descent followed by a long flat meadow walk ending near Vishansar Lake. (12 kms, 6 hours).<br />
The days trek is a long walk on meadows with the scenery changing for the better all along. Start by 8 am to give you enough time en route to enjoy the meadows. Your first destination for the day is to cross the Nichnai pass or Vishansar Berry. The pass is visible at a distance from the campsite. It lies just to the right of the twin snow clad peaks. After half an hour of walking along the river, cross the river to move to its left bank. The next one hour, walk on the left bank. Notice that the trail slowly starts ascending as you traverse through the meadow. The following one hour is a climb to the pass.<br />
As you climb, notic e a small lake at the foot of the mountains. The lake is deep blue in colour and you can sense your expectations raising of the main lakes to come on this trek. The pass is deceptive. The ridge seen from the meadow below is not the pass. The trail turns inwards twice and only then does the Nichnai pass come up. From the Nichanai pass, watch the Sonamarg valley and the trail you came from. BSNL phone network tends to work here most times. This is the last point on the trek where you get phone network. The next sign of network is only when you move beyond Gangabal.<br />
The Nichnai pass feels like a wide tunnel. On the left stand a series of snow clad peaks. There are no peaks on the right but the land raises on the right too. Nichnai pass is at an altitude of 13,500 ft. You are just into your second day of the trek and this by any standard is a very fast ascent. It is not uncommon for people to feel the altitude on the climb to Nichnai pass. The good news is that the trail descends from here on. The rocky trail descends rapidly. In the next hour the rocks give way to grass. Red flowers spring out next to your feet. What you see ahead is a wide green meadow stretching for miles with mountains lining the sides. A new river flows down from the pass into the meadow ahead.<br />
Stop here and take in the view of the peaks, the river below and the flowery meadow. Notice to your left a big waterfall splashing down the mountain cliff and joining the river. From the waterfall, the rapid descent ends and you are now walking through the flat wide meadow. On the left are the classic snow clad Himalayan mountains but notice on your right, grey and barren mountains resembling the Ladakh ranges. Walk along in between the two ranges over the lush green carpet of grass. Two main streams flow through the valley. Stick close to the stream on the left. In half an hour, brace yourselves for another stream crossing for the day. The water is icy cold.<br />
Continue in the meadow for an hour and a half until you reach the end of the valley. Another stream flows perpendicularly from your left to your right. This stream originates at the Vishansar lake which is a bit higher on your left. The lake is not seen yet and cannot be seen from the campsite. Pitch your tents anywhere beside the stream coming from the lake. There is ample camping space. The Vishansar lake lies half a km to the left and 100ft higher from the campsite. Head left and follow the stream without crossing it. The lake is two mounds away and takes about 7 minutes to reach. The first impression you get on seeing the Vishansar lake is that it is big. It lies nestled below 4 mountains.<br />
The Kishansar peak though 0.5 km away, reflects in the lake. The reflections are wonderful when the lake is still. The color of the lake depends on the time of the day and the clouds in the sky. Early in the morning, before the sun really shines, expect clear colorless water. The lake starts getting its colors when the sun shines. On a clear sunny morning, the water is absolutely blue. Clouds and the evening sun make it look greenish blue in the later half of the day. Whatever be the color the lake looks wonderful and it is worth catching a glimpse of the lake in all its hues.<br />
These lakes are full of trouts and trout fishing is popular. Obtain a permit from Srinagar for fishing.</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> Vishansar (12,000ft) to Gadsar(12,000ft) via Kishansar lake and Gadsar Pass (13,750ft)
								</p>
								<p class="aj">Steep 2 hour ascent followed by a steep descent followed a gentle walk in the meadows. (5 hours, 10 kms)<br />
The next lake in series is the Kishansar lake. The Kishansar lake lies just about ½ km away and 500ft higher than Vishansar. The Kishansar lake lies at the base of the Kishansar peak. It takes about 45minutes to reach Kishansar lake from the campsite. Move right towards the stream and cross it where it is easy. The trail climbs up on the right side of the Vishansar lake. There are multiple tracks here. For those keen on photography, the one going up is more attractive as you get the view of the meadow and the lake from a height. For those who prefer an easier trail, stick to the flatter trails. Though the two lakes are only 1.2 km away, there is no point where the two lakes are visible together.<br />
Kishansar is also big and blue. It has a big meadow stretching on its right. The lake and the meadow is bordered on the farther side by a ridge line that raises sharply. The trail climbs up to the top of the ridge and on the top of the ridge is the Gadsar pass.<br />
Spend time at the Kishansar meadows photographing the lake from various angles. The next part of the trek is from Kishansar lake side to the top of the ridge. You see a pencil thin line traversing through the mountain side. That is your track to follow. Always stick to the one going higher though any them will take you to the top. It is an hour and a halfs climb to the top of the ridge a moderate pace. 45 minutes into the climb, you will be treated to one of the loveliest views you can ever imagine. Both the Kishansar and Vishansar lakes are in full view together. The view of the twin lakes lasts till you reach the ridge top or the Pass. This is called as the Gadsar pass ? altitude 13,800ft ? the highest point on this trek.<br />
On the other side of the Gadsar pass stretches a long valley with 2-3 small lakes visible. Far in the distance lie a series of snow clad peaks. The peaks lie outside our Line of Control.<br />
It is not uncommon to find snow at the Gadsar pass and also in the initial parts of the descent to the other side. The descent is straightforward. The first small lake that is seen on the left is the Yamsar lake. The locals tend to believe that lord Yama has some association with the lake! Beyond Yamsar is another nameless lake. An hours descent leads you into flat meadows again. This valley is narrower with two ranges running on your either sides. Notice the multicolored flowers growing up out of the green grass. It starts with red and moves on to blue and purple Iris flowers.<br />
When you are in the blue Iris area, you are almost at Gadsar ? one of the prettiest and most pristine of the lakes on this trek. Gadsar is at the base of snow clad cliffs. Blue flowers spring up one one side and snow slabs fall into the lake from the mountain on the other side. Look ahead to see the green blue valley gently slope down. The Yamsir, the nameless lake and Gadsar are all connected by a stream as water flows from the higher lake to the lower. Gadsar is again at 12,500ft.<br />
Choose to make Gadsar you campsite for its sheer beauty but only if you can vow to leave the ground as neat as you found it to be. No one camps at Gadsar. There is a small abandoned army shelter near Gadsar.<br />
If you choose not to camp next to Gadsar, the next place to camp would be the Gadsar army camp. Continue on the downward trail from Gadsar and in half an hour the valley widens up. Spot another blue lake on the left of the valley. Notice the snow clad mountains now give way to lower barren mountains. You have lost considerable altitude again. In another half an hour down the trail, a few Shepherd huts come up. Continue downhill and at the end of the third half hour, the army camp comes up. Gadsar army camp is just a small hut housing 5-8 army men. To move beyond the army camp, one needs permission from their Head quarters. The Head quarters is 3 miles further away down into the tree line near a village. The Gadsar camp communicates with the HQ through walkie talkies. The HQ is equipped with a satellite phone of the army.<br />
If you are near the Gadsar army camp, it is best to report to them as soon as possible. It takes 2-3 hours for their green signal to come through. All details of the trekkers and staff including original id cards are recorded, collected and checked.</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> Gadsar (12,000ft) to Satsar (12,000ft)
								</p>
								<p class="aj">Gentle descent for 1 hour followed by a steep ascent for 3 hours followed a flat meadow walk. (6 hours, 12 kms)<br />
From the army camp move left towards the stream. The trail crosses the stream and heads up the mountain. The altitude at the stream is 10,600ft. The Satsar camp is at 12,000ft and almost 10 kms away. Crossing the stream is the easiest way to trek. If one really wants to avoid getting their feet wet in the icy cold water, then head to the bridge which a kilometer away and cross the stream. The climb up is steeper if one goes to the bridge.<br />
After crossing the stream, take the trail that goes up the mountain. The trail now looks like a typical western ghat trail. The terrain feels very similar. You are just above the tree line. Trees and the river valley are visible below you. The hour and a half long climb takes you up by 1100ft. Once beyond the 11,500ft altitude, the climb graduates to a traverse. The trail bends round to the left and leaves the river valley. You are now walking on a flat trail surrounded by mountains on a meadow. To you right are a few deep craters. This place is called as Maengandob.<br />
The landscape ahead is captivating. Isolated mountains stand in front. Towards the right is a small ridge. In between is a flat green bed with a stream flowing in between. Choose to camp here if Gadsar lake was your last camp. If the army camp was your start, it makes sense to cover a little more distance today and camp near the first of the Satsar lakes. Satsar is actually a collection of 7 lakes. You can actually find 4 or 5 lakes with water, depending on the season you choose to trek.<br />
Beyond the ridge on the right is the Satsar army check post. It is the 3rd line of defence from the LOC. The same process of ID checking, collection and questioning repeats here too. Finish this today so that tomorrow is a clean day of trekking.<br />
Ten minutes out of the army camp is the first of the Satsar lakes. The lake is pretty big and looks picturesque in its green setting with mountains in front. Choose a place to camp here for the day.</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> Satsar (12,000ft) to Gangabal twin lakes (11,500ft)
								</p>
								<p class="aj">Mild ascent followed by gradual descent followed by long steep ascent and long steep descent followed by gradual up and down walk. (6 hours, 9 kms)<br />
The days trek goes up and down replicating the trek as a whole which mostly goes up and down. Trek up half an hour out of camp, to reach the biggest Satsar lake. The terrain is bouldery and it is more of a boulder hopping exercise than anything else. The biggest of the Satsar lakes is also the last in the sequence. After the last lake the trail starts to descend. Continue for half an hour on the main trail until you see the forest line ahead to your left. The right side is a ridgeline about 1000ft higher. It is time to gain height again. The altitude at the base of the climb is 11,800ft. Take the zig zag pony track to climb up to the top of the first ridge. A 45 minute trek with limited breaks will see you on top of the first ridge. Once on top, you see two more ridges to climb. The trail from the base to top is barren and rocky. Looking behind at the opposite mountains, spot the Gujjar huts amidst the tall pines. You will not fail to notice the bareness of the mountains here and the greenery on the other side.<br />
A total two hour ascent brings you to the top of the 3rd ridge. The altimeter reads about 13,400ft. The best part however is the surprise view you get from the ridge top. Two lakes lie next to one another. A stream takes water from the higher lake to the lower. If you look keenly, two more blue lakes are seen one on either side at a distance. The smaller lakes are nameless but the biggest amongst the set is the Gangabal. Its companion by the side is the Nundkol. You now know your destination. It is 1400ft below you. The route descends a bit more and ascends again to the lake. Take pictures of both sides and brace yourself for a steep stony descent. Your destination is either the Gangabal or the Nundkol. The ascent is dry but on the descent you cross a stream mid way. Fill your empty bottles with the cold water and move on.<br />
An hour and a half steep descent brings you to green meadows again. The meadow is not too wide but stretches from your right to left. A kilo meter down left, you see the tree line again. Once at the base, the lake shore is still a good distance. The destination is seen but seems far away.<br />
A quick climb, a shorter descent and a stream crossing over a wooden log bridge brings you to the shores of Nundkol lake. Notice that this lake is not as pristine as the other lakes you saw on the trek. Remnants of camping are there all around. Lot of people trek up from Naranag to Gangabal and go back as a weekend outing. You will wish they spared time and thought to clean up the mess they created by these beautiful lakes.<br />
The Nundkhol lake lies at the base of the Harmukh peak. The Harmukh glacier hangs on the the sides of the rocky edges of the mountain. Both the Gangabal and Nundkhol are famous for trout fishing.<br />
The Gangabal lake is about 20 minutes away from Nundkhol. A fiery stream flows on the right of the two lakes connecting them. The stream has to be crossed to go to Gangabal from Nandkol. Do not try to cross the stream at the lower levels but go all the way to the bank of Gangabal and on the right you find a good man made bridge laid out. Gangabal is huge. A parikrama of either of the lakes will easily take an hour.</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> Gangabal (11,500ft) to Naranag (7,450ft) Drive to Srinagar
								</p>
								<p class="aj">Gradual descent followed by steep descent. (6 hours, 11kms)<br />
The days trek is a killer on your toes and knees. From the Gangabal campsite head down along the stream towards the tree line. Don't walk beside the stream but walk along the ridge on the right. 30 minutes into the trail, your aircel phone could get glimpses of network just enough to tell home that you are alive. The ridge ends and you descend to a green flat meadow on the right. The Harmukh peak looks impressive when you look back. The green meadow has little yellow flowers growing all over and you start walking gingerly to avoid stepping over them.<br />
An hour out of the campsite, you hit the fringes of the tree line. Pine trees line the meadows and you also see traces of civilization with the presence of a log hut. Do not walk into the forest directly but stick to its fringes and walk towards the right. As a trademark of this trek, you don't lose altitude now but start to climb up a bit. You drop to 10,800ft at the tree line but climb again to 11,000ft. For about 6 kms you never really lose altitude and you are forever around the 10,800ft mark making your way in and out of the Pine forest and finally entering it fully. Only after walking for 2/3 of the distance does the true descent begin. The descent is now really steep. The trail is a well trodden muddy one through the thick of the pines. The last 4 kms sees you dropping more than 3000ft. It is not rare to spot lot of people trekking up here from Naranag headed only to Gangabal.<br />
Naranag slowly comes in sight at around 8500ft but there is quite a bit more to go. The last stretch of the last day does become an endurance test but soon the stone paved village track comes up and in no time you enter the main road of Narnag.</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>
												</ul>
						<br />
												<p class="large b mb5px dif">Exclusions :</p> <ul><li>Transport from Srinagar to Sonamarg and Narnag to Srinagar</li><li>
Hotel Stay in Srinagar.</li><li>
Food during the transit.</li><li>
Insurance.</li><li>
Mules or porter to carry personal luggage.</li><li>
Anything not specifically mentioned under the head.</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.rapidactionexpedition.in/enquiry-form-10002.htm">
						<input type="hidden" name="subject" value="Kashmir Great Lakes Trek 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="100499"/>
						</form>
						</div>
						
						";i:1;s:68:"Book Kashmir Great Lakes Trek Tour - 7 Nights / 8 Days Tour Packages";i:2;s:126:"book kashmir great lakes trek tour - 7 nights / 8 days tour packages, trekking tour packages, srinagar, sonamarg tour packages";i:3;s:166:"Rapid Action Expedition offers Kashmir Great Lakes Trek Tour - 7 Nights / 8 Days tour package, budget Trekking tour packages for Srinagar, Sonamarg at exciting price.";i:4;s:6287:"
			<script type="application/ld+json">
		    {
		      "@context": "https://schema.org",
		      "@type": "TouristAttraction",
		      "address": {
		        "@type": "PostalAddress",
		         "addressRegion": "Srinagar, Sonamarg"        
		                 },
		      "description": "The Kashmir Great Lakes Trek is in no need of an introductory treatise. It presents the proem in itself. You can draw a preface of it by just hearing its name. Kashmir is a wonderful place and if you are on a himalayan trek you are bound to taste the natural beauty and adventure. The trek to the Kashmir Great Lakes Trek offers a lifetime experience of vintage memories that are so wonderfully tiring. The thundering silence of the Kashmir lakes and its virgin beauty is spell bound. Apart from the lakes, even the barren milky snow clad mountains stand out in might and proud.
The location of this trek, as obvious, is Kashmir, also known as the paradise of the earth. The trek duration calculates around 7-9 days and this trek is often graded as moderate in regards to the trekking challenges. The elevation circles around 13000 feet and the distance paths approximately 63 kms. On such a fulfilling trek you will learn so much learn about yourself- in a trifecta – physically, mentally and emotionally. For a trekker, nothing can replace and prepare him for those paramount and conflicting emotions that whether his body will take so much of strain and whether he will make it or not. But the joy on reaching the destination is obvious. This trek will always be happy and a cherishing trek for the trekkers that comes in handy with a few preparations.
As the trek to the Kashmir Great Lakes Trek demands physical fitness, you must take good care of your health, shape yourself well and be fit and fine. Trekkers can train themselves by working out regularly in gym along with running, walking on incline, cycling, cross-training and stretching on a daily basis. Along with physical health mental fitness is important equally.
Coming to the details of the trek, it generally starts from almost 3 kms out of Sonamarg, on the Srinagar road. You can find few dhabbas on your way. It's better to the trekkers to pick up short eats here for the next trace of a dwelling place will be at Naranag that would be probably mark the end of the track.
A few of the trail and the trek enters a green meadow, overlooking the Sonamarg town. At the top of the meadows trekkers reach the starting line of Maple and Pine trees. What follows is a lovey-dovey deep dense forest of Maple trees. Such an experience has always been unique to this trek in India.
You will always be amongst the meadows throughout this trek. The best time to enjoy the Kashmir Great Lakes trek is in between the June and September as the greenery and the blooming flowers are at their best during this calendar period. It's so that a beginner in trekking can also join this trek.
Trailing through the Maple trees uphill, trekkers can enjoy the crystal clear view of the nearby villages downhill and especially the Sonamarg village. Every bit of nature nestles to make a wonderful picture. From here the trail slopes down into yet another meadow lined by the Silver Birch trees and a few shepherd huts. Massively tiny brooks struggling through the meadows and snowy peaks of small mountains mark the land of Shekdur. Shekdur is the only camp site with trees on this trek. It is therefore an add-on in your clicks. The sun rays piercing through the forest, that comes on your way, on further trailing, makes it a nice show of dark and light. Further the trail climbs back into a river valley which is the beginning of Nichanai. You have entered into a wide valley encompassed by the peaks.
After crossing a tunnel-like Nichnai pass followed up by the miles spreading meadow and the cascading waterfall with the icy cold composition of two atoms of Hydrogen and one atom of Oxygen, comes the Vishansar Lake. The first impression that the lake imposes upon the trekker is that of its volume and surrounding provided by the four mountains. It is been followed up by the Kishansar Lake which is only at a distance of 1.2 kms. It has a big meadow stretching by its side. The trail follows up through a ridge. You can see the loveliest view of the two gone-by lakes together from the Gadsar pass which is the highest point of this trek.
Then the time comes to descend. On the way back, the eye captures the view of Yamsir Lake, the nameless lake and the Gadsar Lake which are all connected by all stream. Further you will come to a place called Maengandob where few deep craters are found. The landscape ahead is magnificent for you get to visit Satsar Lakes-collection of seven Lakes and further the twin lakes among which the bigger is the Gangabal and the other one to arrive is Nundkol. On your last destination two Naranag, you are greeted with awe-inspiring glaciers, meadows as well as mountain peaks.
The trek to the Kashmir Great Lakes Trek will provide to the trekkers a perfect flavour of all hues of terrain- innumerable meadows, snow clad glaciers and pinnacles, passes, rocky barren lands, struggling streams. The trail to the Great Lakes is worth trekking. It does justice to all the expectations of a trekker. No individual will ever undergo but this trek will make you undergo. It is a path to heaven and its virgin serenity.
While trekking, trekkers must be equipped with the necessary equipments. Apart from the professional trekking gear, stuffs inclusive of trekking shoes, trekking pole are important specifically. Trekkers must never compromise with their body requirements. It's better to understand your body need and not going by the choice of some other fella. The trek to the Kashmir Great Lakes is not a child's game but even a child of ten years can go on this trek. The luggage or the carry bag should be as light as possible. It will be in your comfort.Transport from Srinagar to Sonamarg and Narnag to Srinagar
Hotel Stay in Srinagar.
Food during the transit.
Insurance.
Mules or porter to carry personal luggage.
Anything not specifically mentioned under the head.",
		      "name": "Kashmir Great Lakes Trek Tour",
		      "telephone": "+91-9411191687"
		    }
		    </script>
			";i:5;N;}