a:4:{i:0;s:5508:"				
				<p class="xxlarge b bdrB orange ffv">Gynaecologist</p>
				<p class="ar mb15px">&bull; <a href="http://www.z2plus.co.in/">Home</a> &bull; Gynaecologist</p>
				<div class="vacancy">
				<p class="bdrB b dif mb10px"><b class="ffv">&raquo;</b> VACANCY DETAILS</p>
				<table class="w95 bdrAll small">
				<tr>
				<td class="w30 data p5px pl7px">Job Title </td>
				<td class="p5px pl10px w1px">:</td>
				<td class="w70 p5px pl7px">Gynaecologist</td>
				</tr>
				
									
					<tr>
					<td class="data p5px pl7px"> Gender Preference </td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">Any</td>
					</tr>
					
										
					<tr>
					<td class="data p5px pl7px"> Number Of Vacancy </td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">2</td>
					</tr>
					
										
					<tr>
					<td class="data p5px pl7px"> Industry Area </td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">Medical / Health Care / Hospitals </td>
					</tr>
					
										
					<tr>
					<td class="data p5px pl7px"> Key Skills </td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">Gynaecologist, Gynaecology </td>
					</tr>
					
										
					<tr>
					<td class="data p5px pl7px"> Qualification </td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">MD/MS </td>
					</tr>
					
											
						<tr>
						<td class="data p5px pl7px"> Salary (Per Annum) </td>
						<td class="p5px pl10px">:</td>
						<td class=" p5px pl7px"> 49 Thousand  9  Hundered  90 9 To  6  Lac  </td>
						</tr>
						
											
					<tr>
					<td class="data p5px pl7px"> Work Experience </td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">1 - 4 Years</td>
					</tr>
					
										
					<tr>
					<td class="data p5px pl7px"> Job Requirement </td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">We Required Gynaecologist for Jharsugda Location.<br />
location- Orissa ,Jharsugda.<br />
salary- as per Industry Standard.<br />
<br />
gynecologist Duties and Responsibilities<br />
    Perform Regular Annual Exams On Patients (e.g. Pap Smears).<br />
    Analyze Records, Reports, Test Results, or Examination Information to Diagnose Medical Condition of Patient.<br />
    Explain Procedures and Discuss Test Results or Prescribed Treatments with Patients.<br />
    Collect, Record, and Maintain Patient Information, such as Medical Histories, Reports, and Examination Results.<br />
    Monitor Patients Over the Course of Pregnancies.<br />
    Treat Infections of the Cervix, Ovaries and Fallopian Tubes.<br />
    Identify Cancerous Growths Within the Reproductive System.<br />
    Refer Patient to Medical Specialist or other Practitioner When Necessary.   <br />
gynecologist Requirements<br />
    Ability to Discuss Sensitive Information with Patients and Families.<br />
    Ability to Provide a Calm Presence for Patients in Distress.<br />
    Ability to Make Decisions Quickly and Stay Calm Under Pressure.<br />
    Experience as An Obstetrician/gynecologist. </td>
					</tr>					
									
				</table>
				</div>
				<br />
				<br />
				<p class="bdrB b dif mb10px"><b class="ffv">&raquo;</b> JOB LOCATION</p>
				<table class="w95 bdrAll small">
				
									
					<tr>
					<td class="w30 data p5px pl7px">Job Country </td>
					<td class="p5px pl10px w1px">:</td>
					<td class="w70 p5px pl7px">India</td>
					</tr>
					
										
					<tr>
					<td class="data p5px pl7px">Job State / U.T.</td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">Odisha</td>
					</tr>
					
										
					<tr>
					<td class="data p5px pl7px">Job City</td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">Jharsuguda					
					</td>
					</tr>
					
									
				</table>
				
								<br />
				<br />
				<p class="bdrB b dif mb10px"><b class="ffv">&raquo;</b> CONTACT DETAILS</p>
				<table class="w95 bdrAll small">
				
									
					<tr>
					<td class="w30 data p5px pl7px">Contact Person</td>
					<td class="p5px pl10px w1px">:</td>
					<td class="w70 p5px pl7px">Shiv Bahadur Singh</td>
					</tr>
					
										
					<tr>
					<td class="w30 data p5px pl7px">Address </td>
					<td class="p5px pl10px w1px">:</td>
					<td class="w70 p5px pl7px">310, CR Avenue, Girish Park, Metro , Kolkata West Bengal ( Pin Code: 700006), India </td>
					</tr>
					
										
					<tr>
					<td class="w30 data p5px pl7px">Mobile </td>
					<td class="p5px pl10px w1px">:</td>
					<td class="w70 p5px pl7px">9230532520 </td>
					</tr>
					
										
					<tr>
					<td class="w30 data p5px pl7px">Email ID </td>
					<td class="p5px pl10px w1px">:</td>
					<td class="w70 p5px pl7px"><a href="mailto:hrz2pluskol@gmail.com"> hrz2pluskol@gmail.com </a> </td>
					</tr>
					
									
				</table>
				
									
					<br class="lh1em" />
					<div class="ac">
					<form name="frmvacdetail" method="post" action="enquiry-form-10009.htm">
					<input class="button" type="submit" value="APPLY NOW !" />
					<input type="hidden" name="catalog_mi" value="333266">
					<input type="hidden" name="enq_type" value="2"><input type="hidden" name="vacancy_id" value="867337"><input type="hidden" name="subject" value="Applied for Gynaecologist">
					</form>
					</div>
			
									
				<br />
				
				";i:1;s:79:"Gynaecologist Jobs in Jharsuguda - Vacancy in Medical / Health Care / Hospitals";i:2;s:168:"Gynaecologist Jobs,Gynaecologist Jobs in Jharsuguda,Gynaecologist Vacancy in Jharsuguda,Gynaecologist jobs in India,Medical / Health Care / Hospitals jobs in Jharsuguda";i:3;s:254:"Apply for Gynaecologist Jobs in Jharsuguda India - Gynaecologist Vacancy  in Medical / Health Care / Hospitals field with 1 to 4 years Work Experience, Key Skills are Gynaecologist, Gynaecology, Medical / Health Care / Hospitals jobs in Jharsuguda  India";}