a:4:{i:0;s:7324:"				<p class="xxlarge b bdrB orange ffv">MSL - Executive Assistant to Chairman, Raigarh</p>
				<p class="ar mb15px">&bull; <a href="http://www.jobmanagement.net/">Home</a> &bull; MSL - Executive Assistant to Chairman, Raigarh</p>
				<div class="vacancy">
				<p style="background:url(http://catalog.wlimg.com/templates-images/11786/11788/bb1.gif) no-repeat 0px 4px; padding-left:12px;" class="large b vacancyTitle">VACANCY DETAILS</p>
				<p style="margin:0 0 10px 12px;" class="bdrBottom"><img src="http://catalog.wlimg.com/templates-images/11786/11788/spacer.gif" /></p>
				<div style="width:95%; margin:0 auto;">
				<table class="w100">
				<tr valign="top">
				<td class="w30 p5px10px b vcBdrB"> Job Title </td>
				<td class="w1px p5px">:</td>
				<td class="w70 p5px10px vccompany vcBdrB b ffv"> MSL - Executive Assistant to Chairman, Raigarh</td>
				</tr>
				
									
					<tr valign="top">
					<td class="p5px10px b vcBdrB"> Gender Preference </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> Any</td>
					</tr>
			
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB"> Number Of Vacancy </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> 1</td>
					</tr>
		
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB"> Industry Area </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> Front Office / Executive Assistant / Data Entry</td>
					</tr>
					
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB"> Key Skills </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> Six Sigma,Excutive Assistant,Excutive Secrety,Personal Assistant,Data Analyst,Strategic Planning,Mis Reporting</td>
					</tr>
			
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB"> Qualification </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> B.Tech/B.E, M.B.A/PGDM, Other Doctorate Degree</td>
					</tr>
					
											
						<tr valign="top">
						<td class="p5px10px b vcBdrB"> Salary (Per Annum) </td>
						<td class="p5px">:</td>
						<td class="p5px10px vcBdrB ffv">  6  Lac  To  7  Lac </td>
						</tr>
						
											
					<tr valign="top">
					<td class="p5px10px b vcBdrB"> Work Experience </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> 3 - 8 Years</td>
					</tr>
					
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB" colspan="3"> Job Requirement </td>
					</tr>
					<tr valign="top">
					<td class="p5px10px" colspan="3"> Maharashtra Seamless Ltd require "Executive Assistant" to Chairman. Plant at Raigad Dist. 100 kms from Pune.<br />
Skills: Auto CAD/ Oracle / SAP/ Technical Presentation/ Six Sigma & 5s require.</td>
					</tr>			
									
				</table>
				</div>
				<br />
				<p style="background:url(http://catalog.wlimg.com/templates-images/11786/11788/bb1.gif) no-repeat 0px 4px; padding-left:12px;" class="large b vacancyTitle">JOB LOCATION</p>
				<p style="margin:0 0 10px 12px;" class="bdrBottom"><img src="http://catalog.wlimg.com/templates-images/11786/11788/spacer.gif" /></p>
				<div style="width:95%; margin:0 auto;">
				<table width="100%"  border="0"  cellpadding="0" cellspacing="0">
			
									<tr valign="top">
					<td width="30%" class="p5px10px b vcBdrB">Job Country </td>
					<td width="1" class="p5px">:</td>
					<td width="70%" class="p5px10px vcBdrB ffv">India</td>
					</tr>
			
										<tr valign="top">
					<td class="p5px10px b vcBdrB">Job State / U.T.</td>
					<td width="1" class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv">Haryana</td>
					</tr>
					
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB">Job City</td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"> Gurgaon					
					</td>
					</tr>
			
									
				</table>
				</div>
				<br />
				
									
					<p style="background:url(http://catalog.wlimg.com/templates-images/11786/11788/bb1.gif) no-repeat 0px 4px; padding-left:12px;" class="large b vacancyTitle">COMPANY PROFILE </p>
					<p style="margin:0 0 10px 12px;" class="bdrBottom"><img src="http://catalog.wlimg.com/templates-images/11786/11788/spacer.gif" /></p>
					<div style="width:95%; margin:0 auto;">
					<table width="100%"  border="0"  cellpadding="0" cellspacing="0">
				
											
						<tr valign="top">
						<td width="30%" class="p5px10px b vcBdrB">Company Name</td>
						<td width="1" class="p5px">:</td>
						<td width="70%" class="p5px10px vcBdrB ffv">Job Management Institute</td>
						</tr>
				
												
						<tr valign="top">
						<td width="30%" class="p5px10px b vcBdrB">About Company</td>
						<td width="1" class="p5px">:</td>
						<td width="70%" class="p5px10px vcBdrB ffv">Job Management was established in the year 2006 as an initiative to provide manpower from entry level to senior level for various organizations across India and abroad. The firm has excelled in this field under the successful management of Mr. Basant Lakhotia. We have carved a niche in the industry by offering Manpower Recruitment, Staffing Solutions and recruiting for Work At Home opportunities. We are located in Mumbai, India.</td>
						</tr>
				
											</table>
					</div>
					<br />
									
				<p style="background:url(http://catalog.wlimg.com/templates-images/11786/11788/bb1.gif) no-repeat 0px 4px; padding-left:12px;" class="large b vacancyTitle">CONTACT DETAIL </p>
				<p style="margin:0 0 10px 12px;" class="bdrBottom"><img src="http://catalog.wlimg.com/templates-images/11786/11788/spacer.gif" /></p>
				<div style="width:95%; margin:0 auto;">
				<table width="100%"  border="0"  cellpadding="0" cellspacing="0">
			
									
					<tr valign="top">
					<td width="30%" class="p5px10px b vcBdrB">Contact Person</td>
					<td width="1" class="p5px">:</td>
					<td width="70%" class="p5px10px vcBdrB ffv">Basant</td>
					</tr>
					
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB">Address </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv">Off Link Road, Mitha Nagar, Goregaon(w)</td>
					</tr>
					
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB">Mobile </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv">9594935253</td>
					</tr>
					
										
					<tr valign="top">
					<td class="p5px10px b vcBdrB">Email ID </td>
					<td class="p5px">:</td>
					<td class="p5px10px vcBdrB ffv"><a href="mailto:bl@jobmanagement.net">bl@jobmanagement.net</a> </td>
					</tr>
					
									
				
				</table>
				</div>
			
									
					<br class="lh1em" />
					<div class="ac">
					<form name="frmvacdetail" method="post" action="enquiry-form-10009.htm">
					<input class="Btn" type="submit" value="APPLY NOW !" />
					<input type="hidden" name="catalog_mi" value="276155">
					<input type="hidden" name="enq_type" value="2"><input type="hidden" name="vacancy_id" value="429349"><input type="hidden" name="subject" value="Applied for MSL - Executive Assistant to Chairman, Raigarh">
					</form>
					</div>
			
									
				</div>
				<br />
				
				";i:1;s:123:"MSL - Executive Assistant to Chairman, Raigarh Jobs in Gurgaon - Vacancy in Front Office / Executive Assistant / Data Entry";i:2;s:305:"MSL - Executive Assistant to Chairman, Raigarh Jobs,MSL - Executive Assistant to Chairman, Raigarh Jobs in Gurgaon,MSL - Executive Assistant to Chairman, Raigarh Vacancy in Gurgaon,MSL - Executive Assistant to Chairman, Raigarh jobs in India,Front Office / Executive Assistant / Data Entry jobs in Gurgaon";i:3;s:426:"Apply for MSL - Executive Assistant to Chairman, Raigarh Jobs in Gurgaon India - MSL - Executive Assistant to Chairman, Raigarh Vacancy  in Front Office / Executive Assistant / Data Entry field with 3 to 8 years Work Experience, Key Skills are Six Sigma,Excutive Assistant,Excutive Secrety,Personal Assistant,Data Analyst,Strategic Planning,Mis Reporting, Front Office / Executive Assistant / Data Entry jobs in Gurgaon  India";}