Postgraduate School | University of Jos - Nigeria

Postgraduate School | University of Jos - Nigeria
Skip to main content
x
Warning message
Deprecated function
: strpos(): Passing null to parameter #1 ($haystack) of type string is deprecated in
do_shortcode()
(line
191
of
modules/gva_blockbuilder/includes/core/shortcode.php
).
do_shortcode(NULL) (Line: 67)
Drupal\gavias_blockbuilder\shortcodes\gsc_accordion::sc_accordion(Array) (Line: 54)
Drupal\gavias_blockbuilder\shortcodes\gsc_accordion->render_content(Array) (Line: 85)
include('/var/www/html/unijos/modules/gva_blockbuilder/templates/frontend/print-builder.php') (Line: 92)
gavias_blockbuilder_frontend('[{"attr":{"bg_image":"","bg_color":"","bg_position":"center top","bg_repeat":"no-repeat","bg_attachment":"fixed","bg_size":"contain","bg_video":"","bg_video_mp4":"","bg_video_webm":"","bg_video_ogv":"","style_space":"default","padding_top":"0","padding_bottom":"0","margin_top":"0","margin_bottom":"0","layout":"container","equal_height":"","icon":"","class":"","row_id":""},"columns":{"1":{"attr":{"size":"12","type":"","bg_image":"","bg_color":"","bg_position":"center top","bg_repeat":"no-repeat","bg_attachment":"scroll","bg_size":"cover","class":"","class_inner":"","column_id":"","hidden_lg":"show","hidden_md":"show","hidden_sm":"show","hidden_xs":"show"},"items":[{"type":"gsc_heading","size":12,"fields":{"title":"School of Postgraduate Studies","sub_title":"Academic","desc":"<div class=\"pull-center text-center\"><a class=\"btn btn-primary btn-sm\" type=\"button\">Postgraduate School Admission 2024<\/a><\/div>","icon":"","align":"align-center","style":"style-default","style_text":"text-dark","remove_padding":"","el_class":"","animate":""}},{"type":"gsc_button","size":12,"fields":{"title":"","size":"mini","color":"#000","border_color":"#000","background_color":"","border_radius":"","link":"","color_hover":"","border_color_hover":"","background_color_hover":"","animate":"","el_class":""}}]},"2":{"attr":{"size":"3","type":"","bg_image":"","bg_color":"","bg_position":"center top","bg_repeat":"no-repeat","bg_attachment":"scroll","bg_size":"cover","class":"","class_inner":"","column_id":"","hidden_lg":"show","hidden_md":"show","hidden_sm":"show","hidden_xs":"show"},"items":[{"type":"gsc_our_team","size":12,"fields":{"title":"Prof. Dakul Anthony","job":"Dean","image":"","content":"","facebook":"","twitter":"","pinterest":"","google":"","style":"vertical","content_align":"left","link":"","target":"0","el_class":"","animate":""}}]},"3":{"attr":{"size":"9","type":"","bg_image":"","bg_color":"","bg_position":"center top","bg_repeat":"no-repeat","bg_attachment":"scroll","bg_size":"cover","class":"","class_inner":"","column_id":"","hidden_lg":"show","hidden_md":"show","hidden_sm":"show","hidden_xs":"show"},"items":[{"type":"gsc_column","size":12,"fields":{"title":"","content":"","style":"","animate":"","el_class":""}}]}}},{"attr":{"bg_image":"","bg_color":"","bg_position":"center top","bg_repeat":"no-repeat","bg_attachment":"scroll","bg_size":"cover","bg_video":"","bg_video_mp4":"","bg_video_webm":"","bg_video_ogv":"","style_space":"default","padding_top":"0","padding_bottom":"0","margin_top":"0","margin_bottom":"0","layout":"container","equal_height":"","icon":"","class":"","row_id":""},"columns":{"1":{"attr":{"size":"6","type":"","bg_image":"","bg_color":"","bg_position":"center top","bg_repeat":"no-repeat","bg_attachment":"scroll","bg_size":"cover","class":"","class_inner":"","column_id":"","hidden_lg":"show","hidden_md":"show","hidden_sm":"show","hidden_xs":"show"},"items":[{"type":"gsc_column","size":12,"fields":{"title":"Postgraduate School ","content":"<p class=\"MsoNormal\" style=\"mso-margin-top-alt: auto; mso-margin-bottom-alt: auto; line-height: normal; mso-outline-level: 1;\"><strong><span style=\"font-size: 18.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">General Admission Requirement: <\/span><\/strong><span style=\"mso-tab-count: 1;\">\u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u00a0<\/span><\/p>\r\n<p class=\"MsoListParagraph\" style=\"margin-left: 32.2pt; mso-add-space: auto; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">1. A candidate seeking admission must possess five credit passes including English and Mathematics and other relevant subjects at O' Level. Candidates seeking Admission into a Master\u2019s Degree or Postgraduate Diploma of the University of Jos must hold a good (First or second class) Honours Degree of this University or of other Universities recognized by the Senate of University of Jos. The first degree must be in a discipline relevant to the programme into which admission is being sought.<br \/> <br \/> 2. A candidate seeking admission into an M.Phil\/Ph.D. programme must in addition possess a Master\u2019s degree in the relevant discipline. M.Phil\/Ph.D. candidates are in addition required to have returned a weighted Score Average (WSA) of 60% and above in the final assessment result for the Master\u2019s Degree as well as 60% and above in the Research Project. On admission, M.Phil\/Ph.D candidates register for M.Phil in the first instance and on satisfactory performance may be subsequently upgraded to Ph.D. registration.<br \/> <br \/> 3. For all admissions, degree result transcripts are required.<br \/> <br \/> 4. All Advertised programmes will run on a full-time basis.<\/span><\/p>","style":"","animate":"","el_class":""}},{"type":"gsc_accordion","size":12,"fields":{"title":"Application Requirements","style":"skin-white","count":"17","tabs":[{"icon":"","title":"FACULTY OF ARTS","content":"<p class=\"MsoNormal\" style=\"margin-bottom: 6.0pt; text-align: justify; line-height: normal;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">A. DEPARTMENT OF ENGLISH<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal; margin: 0cm 0cm .0001pt 36.0pt;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">1. <span style=\"mso-tab-count: 1;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>MA English Language<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal; margin: 0cm 0cm .0001pt 36.0pt;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">2. <span style=\"mso-tab-count: 1;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>MA Literature in English<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal; margin: 0cm 0cm .0001pt 36.0pt;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">3. <span style=\"mso-tab-count: 1;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>MA Oral Literature<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal; margin: 0cm 0cm .0001pt 36.0pt;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">4. <span style=\"mso-tab-count: 1;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>MPhil\/PhD English Language<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal; margin: 0cm 0cm .0001pt 36.0pt;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">5. <span style=\"mso-tab-count: 1;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>MPhil\/PhD Literature in English<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal; margin: 0cm 0cm .0001pt 36.0pt;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">6. <span style=\"mso-tab-count: 1;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>MPhil\/PhD Oral Literature<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; text-indent: -18.0pt; line-height: 85%; margin: 0cm 0cm .0001pt 18.0pt;\">\u00a0<\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; text-indent: -18.0pt; line-height: 85%; margin: 0cm 0cm .0001pt 18.0pt;\"><strong><span style=\"font-size: 12.0pt; line-height: 85%; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">B. DEPARTMENT OF HISTORY AND INTERNATIONAL STUDIES<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraph\" style=\"text-align: justify; text-indent: -27.0pt; mso-text-indent-alt: -3.0pt; line-height: normal; mso-list: l0 level1 lfo1; margin: 0cm 0cm .0001pt 27.0pt;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\"><span style=\"mso-list: Ignore;\"><span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>i.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">M.A. Economic History<\/span><\/p>\r\n<p class=\"MsoListParagraph\" style=\"text-align: justify; text-indent: -27.0pt; mso-text-indent-alt: -3.0pt; line-height: normal; mso-list: l0 level1 lfo1; margin: 0cm 0cm .0001pt 27.0pt;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\"><span style=\"mso-list: Ignore;\"><span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>ii.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">M.A. African History<\/span><\/p>\r\n<p class=\"MsoListParagraph\" style=\"text-align: justify; text-indent: -27.0pt; mso-text-indent-alt: -3.0pt; line-height: normal; mso-list: l0 level1 lfo1; margin: 0cm 0cm .0001pt 27.0pt;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\"><span style=\"mso-list: Ignore;\"><span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>iii.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">M.A. History and International Studies<\/span><\/p>\r\n<p class=\"MsoListParagraph\" style=\"text-align: justify; text-indent: -27.0pt; mso-text-indent-alt: -3.0pt; line-height: normal; mso-list: l0 level1 lfo1; margin: 0cm 0cm .0001pt 27.0pt;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\"><span style=\"mso-list: Ignore;\"><span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>iv.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">M.Phil\/Ph.D Economic History<\/span><\/p>\r\n<p class=\"MsoListParagraph\" style=\"text-align: justify; text-indent: -27.0pt; mso-text-indent-alt: -3.0pt; line-height: normal; mso-list: l0 level1 lfo1; margin: 0cm 0cm .0001pt 27.0pt;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\"><span style=\"mso-list: Ignore;\"><span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>v.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">M.Phil\/Ph.D African History<\/span><\/p>\r\n<p class=\"MsoListParagraph\" style=\"text-align: justify; text-indent: -26.65pt; mso-text-indent-alt: -2.9pt; line-height: normal; mso-list: l0 level1 lfo1; margin: 0cm 0cm .0001pt 26.65pt;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\"><span style=\"mso-list: Ignore;\"><span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>vi.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">M.Phil\/Ph.D History and International Studies<\/span><\/p>\r\n<p class=\"MsoListParagraph\" style=\"margin: 0cm; margin-bottom: .0001pt; text-align: justify; line-height: normal;\">\u00a0<\/p>\r\n<p class=\"MsoListParagraph\" style=\"margin: 0cm; margin-bottom: .0001pt; text-align: justify; line-height: normal;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">C. DEPARTMENT OF LINGUISTICS AND NIGERIAN LANGUAGES<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">Programmes:<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">M Phil\/Ph.D in Linguistics<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">M. A Linguistics<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; text-indent: -22.5pt; line-height: normal; margin: 0cm 0cm .0001pt 22.5pt;\"><strong><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">D. DEPARTMENT OF MASS COMMUNICATION<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -13.7pt; line-height: normal; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\"><span style=\"mso-list: Ignore;\">i.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">Postgraduate Diploma in Mass Communication <\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -13.7pt; line-height: normal; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\"><span style=\"mso-list: Ignore;\">ii.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">M.A Mass Communication<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -13.7pt; line-height: normal; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\"><span style=\"mso-list: Ignore;\">iii.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">MPhil\/Ph.D Mass Communication<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: normal;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">E. DEPARTMENT OF RELIGION AND PHILOSOPHY<\/span><\/strong><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">a. M.A Arabic<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">b. M.A. Ethics and Philosophy<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">c. M.A New Testament<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">d. M.A Sociology of Religions<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">e. M.A Church History<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">f. M.A Interaction of Religions<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">g. <span style=\"mso-bidi-font-weight: bold;\">M.A Old Testament<\/span><\/span><\/p>\r\n<p class=\"MsoNoSpacing\" style=\"tab-stops: 135.75pt;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-weight: bold;\">h. <\/span><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">M.A Islamic Studies<span style=\"mso-tab-count: 1;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">i. M.A African Traditional Religion<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">MPHIL\/PHD PROGRAMMES<\/span><\/strong><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">a. MPhil\/PhD. Arabic<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">b. MPhil\/PhD. Ethics and Philosophy<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">c. MPhil\/PhD. New Testament<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">d. MPhil\/PhD. Sociology of Religions<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">e. MPhil\/PhD. Church History<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">f<span style=\"mso-spacerun: yes;\">\u00a0\u00a0 <\/span>MPhil\/PhD. Interaction of Religions<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">g. MPhil\/PhD. <span style=\"mso-bidi-font-weight: bold;\">Old Testament<\/span><\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-weight: bold;\">h. <\/span><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">MPhil\/PhD. Islamic Studies<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">i.<span style=\"mso-spacerun: yes;\">\u00a0 <\/span>MPhil\/PhD. African Traditional Religion<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">F. Department of Theatre and Film Arts<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">a. <\/span><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">M.A Play creating<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">b. M.A Directing<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">c. M.A Dramatic Literature & Criticism<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">d. M.A Film Arts<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">e. M.A. Development Theatre\/Communication Studies<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">g. MPhil\/PhD. Theatre and Film Arts<\/span><\/p>\r\n<p class=\"MsoNoSpacing\"><strong><span lang=\"EN-GB\">G. DEPARTMENT OF ARCHAEOLOGY AND HERITAGE STUDIES<\/span><\/strong><\/p>\r\n<p class=\"Default\" style=\"text-align: justify; line-height: 115%;\"><span lang=\"EN-GB\" style=\"mso-bidi-font-weight: bold;\">a. <\/span><span lang=\"EN-GB\">M.A. Degree in Archaeology <\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify; line-height: 115%;\"><span lang=\"EN-GB\">b. MPhil Degree in Archaeology <\/span><\/p>"},{"icon":"","title":"FACULTY OF AGRICULTURE","content":"<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><strong><span style=\"font-size: 16.0pt; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">Department of Animal Production<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"text-indent: -18.0pt; line-height: normal; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12pt; font-family: 'Times New Roman', serif;\">1.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-style: italic;\">Postgraduate Diploma (PGD) Animal Production <\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"text-indent: -18.0pt; line-height: normal; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"font-size: 12pt; font-family: 'Times New Roman', serif;\">2.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-style: italic;\">M.Sc. in <\/span><span lang=\"EN-GB\" style=\"font-size: 12pt; font-family: 'Times New Roman', serif;\">Animal Science<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"text-indent: -18.0pt; line-height: normal; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"font-size: 12pt; font-family: 'Times New Roman', serif;\">3.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">MPhil\/PhD. Animal Science<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: normal;\"><span lang=\"EN-GB\" style=\"font-size: 12pt; font-family: 'Times New Roman', serif;\">(b)\u00a0\u00a0\u00a0<\/span><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-style: italic;\">M.Sc. in <\/span><span lang=\"EN-GB\" style=\"font-size: 12pt; font-family: 'Times New Roman', serif;\">Animal Science (Options in <\/span><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">Animal Breeding and Genetics, Monogastric Nutrition, Ruminant Nutrition, Animal Management\/Production, Pasture and Rangeland Management\/Production, Animal Products and Processing, Animal Physiology and Reproduction)<\/span><\/p>\r\n<p class=\"MsoHeader\" style=\"text-align: justify;\"><span lang=\"EN-GB\" style=\"font-size: 12pt; font-family: 'Times New Roman', serif;\">(c)\u00a0\u00a0\u00a0\u00a0<\/span><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">MPhil\/PhD. Animal Science (with options in Animal Breeding and Genetics, Monogastric Nutrition, Ruminant Nutrition, Animal Management\/Production, Pasture and Rangeland Management\/Production, Animal Products and Processing, Animal Physiology and Reproduction)<\/span><\/p>\r\n<p class=\"MsoHeader\" style=\"text-align: justify;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-style: italic;\">\u00a0<\/span><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-style: italic;\">\u00a0<\/span><strong><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">Areas of Specialization at PG level<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 115%; mso-list: l0 level1 lfo1; margin: 0cm 0cm 10.0pt 54.0pt;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">1<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif;\">Animal Breeding and Genetics<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 115%; mso-list: l0 level1 lfo1; margin: 0cm 0cm 10.0pt 54.0pt;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">2<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif;\">Monogastric Animal Nutrition <\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 115%; mso-list: l0 level1 lfo1; margin: 0cm 0cm 10.0pt 54.0pt;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">3<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif;\">Ruminant Animal Nutrition<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 115%; mso-list: l0 level1 lfo1; margin: 0cm 0cm 10.0pt 54.0pt;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">4<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif;\">Animal Management\/Production<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 115%; mso-list: l0 level1 lfo1; margin: 0cm 0cm 10.0pt 54.0pt;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">5<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif;\">Pasture and Rangeland Management\/Production<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 115%; mso-list: l0 level1 lfo1; margin: 0cm 0cm 10.0pt 54.0pt;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">6<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif;\">Animal Products and Processing<\/span><\/p>\r\n<p><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: Calibri; mso-fareast-theme-font: minor-latin; mso-font-kerning: 1.0pt; mso-ligatures: standardcontextual; mso-ansi-language: EN-US; mso-fareast-language: EN-US; mso-bidi-language: AR-SA;\">Animal Physiology and Reproduction<\/span><\/p>"},{"icon":"","title":"\u00a0FACULTY OF BASIC CLINICAL SCIENCES","content":"<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; color: black; mso-themecolor: text1; mso-font-kerning: 0pt;\">A. DEPARTMENT OF CHEMICAL PATHOLOGY<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraph\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-indent: -36.0pt; mso-text-indent-alt: -18.0pt; line-height: 115%; mso-list: l2 level1 lfo1;\"><!-- [if !supportLists]--><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; color: black; mso-themecolor: text1;\"><span style=\"mso-list: Ignore;\"><span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>I.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><\/strong><!--[endif]--><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; color: black; mso-themecolor: text1;\">MSc in Clinical Pathology\/ Clinical Biochemistry<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; color: black; mso-themecolor: text1;\">\u00a0<\/span><\/strong><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; color: black; mso-themecolor: text1;\">B. DEPARTMENT OF MEDICAL MICROBIOLOGY<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"mso-add-space: auto; text-indent: -38.7pt; mso-text-indent-alt: -18.0pt; line-height: 115%; mso-list: l0 level1 lfo2; margin: 0cm 0cm .0001pt 38.7pt;\"><!-- [if !supportLists]--><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; color: black; mso-themecolor: text1;\"><span style=\"mso-list: Ignore;\"><span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>I.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><\/strong><!--[endif]--><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; color: black; mso-themecolor: text1;\">MSc. Medical Microbiology <\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"mso-add-space: auto; text-indent: -38.7pt; mso-text-indent-alt: -18.0pt; line-height: 115%; mso-list: l0 level1 lfo2; margin: 0cm 0cm .0001pt 38.7pt;\"><!-- [if !supportLists]--><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; color: black; mso-themecolor: text1;\"><span style=\"mso-list: Ignore;\"><span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>II.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><\/strong><!--[endif]--><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; color: black; mso-themecolor: text1;\">PhD Medical Microbiology <\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; color: black; mso-themecolor: text1;\">Available Areas of Research in Medical Microbiology <\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; color: black; mso-themecolor: text1;\">A candidate may undertake research in any of the major specialties below:<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-indent: -36.0pt; mso-text-indent-alt: -18.0pt; line-height: 115%; mso-list: l1 level1 lfo3;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; color: black; mso-themecolor: text1;\"><span style=\"mso-list: Ignore;\"><span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>1.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; color: black; mso-themecolor: text1;\">Bacteriology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-indent: -36.0pt; mso-text-indent-alt: -18.0pt; line-height: 115%; mso-list: l1 level1 lfo3;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; color: black; mso-themecolor: text1;\"><span style=\"mso-list: Ignore;\"><span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>2.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; color: black; mso-themecolor: text1;\">Immunology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-indent: -36.0pt; mso-text-indent-alt: -18.0pt; line-height: 115%; mso-list: l1 level1 lfo3;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; color: black; mso-themecolor: text1;\"><span style=\"mso-list: Ignore;\"><span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>3.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; color: black; mso-themecolor: text1;\">Medical Mycology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-indent: -36.0pt; mso-text-indent-alt: -18.0pt; line-height: 115%; mso-list: l1 level1 lfo3;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; color: black; mso-themecolor: text1;\"><span style=\"mso-list: Ignore;\"><span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>4.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; color: black; mso-themecolor: text1;\">Parasitology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-bottom: 6.0pt; mso-add-space: auto; text-indent: -36.0pt; mso-text-indent-alt: -18.0pt; line-height: normal; mso-list: l1 level1 lfo3;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; color: black; mso-themecolor: text1; mso-font-kerning: 0pt;\"><span style=\"mso-list: Ignore;\"><span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>5.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; color: black; mso-themecolor: text1; mso-font-kerning: 0pt;\">Virology.<\/span><\/p>"},{"icon":"","title":"FACULTY OF BASIC MEDICAL SCIENCES","content":"<p class=\"MsoNormal\" style=\"text-indent: -18.0pt; line-height: normal; margin: 0cm 0cm 6.0pt 18.0pt;\"><strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">A. DEPARTMENT OF BIOCHEMISTRY<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 107%; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">i.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif;\">Postgraduate Diploma in Nutrition and Dietetics.<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 107%; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">ii.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif;\">M.Sc. Biochemistry<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 107%; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">iii.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif;\">M.Phil\/Ph.D. Biochemistry<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: 107%;\"><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif; mso-bidi-font-weight: bold;\">Areas of Specialization<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 107%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">i.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif;\">Medical Biochemistry(cancer and diabetes)<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 107%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">ii.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif;\">Molecular Biology and Biotechnology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 107%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">iii.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif;\">Parasite Biochemistry <\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 107%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">iv.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif;\">Environmental Biochemistry<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 107%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">v.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif;\">Nutrition and Nutrigenomics <\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 107%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">vi.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif;\">Toxicology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 107%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">vii.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif;\">Phytomedicine\/Ethnobiochemistry<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 107%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">viii.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif;\">Micro biome<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 107%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">ix.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif;\">Forensic Biochemistry <\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-align: justify; text-indent: -36.0pt; line-height: 107%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">x.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 107%; font-family: 'Times New Roman',serif;\">Drug Research<\/span><\/p>\r\n<p class=\"MsoNoSpacing\" style=\"text-align: justify;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-font-kerning: 1.0pt; mso-ligatures: standardcontextual;\">\u00a0<\/span><strong><span style=\"font-size: 12.0pt; mso-bidi-font-size: 11.0pt; font-family: 'Times New Roman',serif;\">B. DEPARTMENT OF HUMAN ANATOMY<\/span><\/strong><\/p>\r\n<p class=\"MsoNoSpacing\" style=\"text-align: justify;\"><span style=\"font-size: 12.0pt; mso-bidi-font-size: 11.0pt; font-family: 'Times New Roman',serif;\">\u00a0\u00a0\u00a0\u00a0 i. <\/span><span style=\"font-family: 'Times New Roman',serif;\">M.Sc. Human Anatomy <\/span><\/p>\r\n<p class=\"MsoNoSpacing\" style=\"text-align: justify;\"><span style=\"font-family: 'Times New Roman',serif;\">\u00a0\u00a0\u00a0 ii. M.Phil\/Ph.D Human Anatomy<\/span><\/p>\r\n<p class=\"MsoNormal\"><strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; color: red;\">\u00a0<\/span><\/strong><strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">C. DEPARTMENT OF HUMAN PHYSIOLOGY<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">i. M.Sc. Physiology<\/span><\/p>\r\n<p><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: Calibri; mso-fareast-theme-font: minor-latin; mso-font-kerning: 1.0pt; mso-ligatures: standardcontextual; mso-ansi-language: EN-US; mso-fareast-language: EN-US; mso-bidi-language: AR-SA;\">ii. M.Phil\/Ph.D. Physiology<\/span><\/p>"},{"icon":"","title":"FACULTY OF CLINICAL SCIENCES","content":"<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: 150%;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">A. DEPARTMENT OF OBSTETRICS AND GYNAECOLOGY<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: 150%;\"><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">1. Master of Reproductive Sciences <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: 150%;\"><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">2. MPhil\/Ph.D Reproductive Sciences <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: 150%;\"><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">3. MD Reproductive Sciences\/OBGYN <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: 150%;\"><span lang=\"EN-GB\" style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi; color: black; mso-ansi-language: EN-GB; mso-fareast-language: EN-GB;\">4. Doctor of Medicine (MD) Degree Programme in Obstetrics and Gynaecology<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: normal;\"><span lang=\"EN-GB\" style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi; color: black; mso-ansi-language: EN-GB; mso-fareast-language: EN-GB;\">\u00a0<\/span><strong><span lang=\"EN-GB\" style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi; color: black; mso-ansi-language: EN-GB; mso-fareast-language: EN-GB;\">B<\/span><\/strong><strong><span lang=\"EN-GB\" style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi; mso-ansi-language: EN-GB; mso-fareast-language: EN-GB;\">. <\/span><\/strong><span class=\"Heading2Char\"><span lang=\"EN-GB\" style=\"font-size: 13.0pt; letter-spacing: -.5pt;\">DEPARTMENT OF COMMUNITY MEDICINE<\/span><\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal; margin: 0cm 0cm .0001pt 22.5pt;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\">i.<span style=\"mso-spacerun: yes;\">\u00a0 <\/span>M.Sc. Clinical Epidemiology<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal; margin: 0cm 0cm .0001pt 22.5pt;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\">ii. M.Sc. Field Epidemiology<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal; margin: 0cm 0cm .0001pt 22.5pt;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\">iii. Masters of Public Health<\/span><\/p>"},{"icon":"","title":"FACULTY OF EDUCATION","content":"<p>\u00a0<\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><strong>A<\/strong>. <strong>DEPARTMENT OF ADULT EDUCATION<\/strong><\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">1. <\/span><\/strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\"><span style=\"mso-spacerun: yes;\">\u00a0<\/span>MPhil\/Ph.D. Adult Education <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">2. <span style=\"mso-spacerun: yes;\">\u00a0<\/span>Master of Education (Adult Education)<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">3. Postgraduate Diploma (PGD) in Adult Education and Community Development<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify;\"><strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">Available specializations<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">1.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">Adult and Non-Formal Education <\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">2.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">Community Development<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">3.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">Social Welfare<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">4.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">Industrial Education<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">5.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">Communication Arts in Adult Education\/Community Development<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">6.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">Vocational Adult Education<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">7.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">Cooperative Management<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">8.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">Distance Education<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">9.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif;\">Extension Education<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; line-height: normal;\"><strong><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">B. DEPARTMENT OF SPECIAL EDUCATION AND REHABILITATION SCIENCES<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"> 1. M.Phil\/Ph.D Hearing Handicap<br \/> 2. M.Phil\/Ph.D Learning Disabilities<br \/> 3. M.Phil\/Ph.D Visual Handicaps<br \/> 4. M.Ed. Hearing Handicap<br \/> 5. M.Ed. Learning Disabilities<br \/> 6. M.Ed. Visual Handicaps.<br \/> <br \/> <strong>C. DEPARTMENT OF ARTS EDUCATION<\/strong><br \/> 1. M.Phil\/Ph.D. History and International Studies Education<br \/> 2. M.Phil\/Ph.D. Religion Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">3. MPhil\/Ph.D. English Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">4. MPhil\/Ph.D. French Education<br \/> 5. M.Ed. English Education<br \/> 6. M.A. Ed. History and International Studies Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none; mso-bidi-font-weight: bold;\">7. <span style=\"mso-spacerun: yes;\">\u00a0<\/span>M.Ed. French Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none; mso-bidi-font-weight: bold;\">8. M.Ed. Religion Education<\/span><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><br \/> <br \/> <strong>D. DEPARTMENT OF EDUCATIONAL FOUNDATION<\/strong><br \/> 1. M.Phil\/Ph.D. Guidance and Counseling<br \/> 2. M.Phil\/Ph.D. Philosophy of Education<br \/> 3. M.Phil\/Ph.D. Sociology of Education<br \/> 4. M.Phil\/Ph.D. Educational Psychology<br \/> 5. M.Phil\/Ph.D. Educational Research, Measurement and Evaluation<br \/> 6. M.Phil\/Ph.D. Educational Management<br \/> 7. M.Ed. Guidance and Counseling<br \/> 8. M.Ed. Philosophy of Education<br \/> 9. M.Ed. Sociology of Education<br \/> 10. M.Ed. Educational Psychology<br \/> 11. M.Ed. Educational Research, Measurement and Evaluation<br \/> 12. M.Ed. Educational Management<br \/> <br \/> <strong>E. DEPARTMENT OF SOCIAL SCIENCE EDUCATION<\/strong><br \/> 1. M.Phil\/Ph.D. Social Studies Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-fareast-language: EN-ZA; mso-bidi-font-weight: bold;\">2. MPhil\/PhD. Library and Information Science<\/span><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><br \/> 3. M.Ed. Social Studies Education<br \/> 4. M.Sc. Ed. Economics Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-fareast-language: EN-ZA; mso-bidi-font-weight: bold;\">5. Master in Library and Information Science (MLIS) <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-weight: bold;\">6. <\/span><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-fareast-language: EN-ZA; mso-bidi-font-weight: bold;\">Postgraduate Diploma in Library and Information Science (PGDLIS)<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-indent: -18.0pt; margin: 0cm 0cm .0001pt 18.0pt;\">\u00a0<\/p>\r\n<p class=\"MsoNormal\" style=\"text-indent: -18.0pt; margin: 0cm 0cm .0001pt 18.0pt;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">F. DEPARTMENT OF PHYSICAL AND HEALTH<span style=\"mso-spacerun: yes;\">\u00a0 <\/span>EDUCATION.<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"text-indent: -18.0pt; margin: 0cm 0cm .0001pt 18.0pt;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">1. MPhil\/Ph.D. Physical Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-indent: -18.0pt; margin: 0cm 0cm .0001pt 18.0pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>2. MPhil\/Ph.D. Health Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-indent: -18.0pt; margin: 0cm 0cm .0001pt 18.0pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>3. M.Sc. Ed Physical Education <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-indent: -18.0pt; margin: 0cm 0cm .0001pt 18.0pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>4. <span style=\"mso-spacerun: yes;\">\u00a0<\/span>M.Sc. Ed. Health Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-indent: -18.0pt; margin: 0cm 0cm .0001pt 18.0pt;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">Areas of specialisation<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: 115%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">a.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif;\"><span style=\"mso-spacerun: yes;\">\u00a0<\/span>Sports Management<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: 115%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">b.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif;\">Exercise and Sports Science<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: 115%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">c.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif;\">Physical Education Curriculum<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: 115%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">d.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif;\">Health Education Curriculum<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: 115%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">e.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif;\">Public Health Education & Community Health Education<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: 115%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">f.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif;\">School health Education<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: 115%; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">g.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif;\">Environmental Health Education<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; line-height: 115%;\"><strong><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">G. DEPARTMENT OF SCIENCE AND TECHNOLOGY EDUCATION<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: 115%;\"><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"> 1. M.Phil.\/Ph.D. Biology Education<br \/> 2. M.Phil.\/Ph.D. Chemistry Education<br \/> 3. M.Phil.\/Ph.D. Physics Education<br \/> 4. M.Phil.\/Ph.D. Educational Technology<br \/> 5. M.Phil.\/Ph.D. Mathematics Education<br \/> 6. M.Phil.\/Ph.D. Science Education<br \/> 7. M.Phil.\/Ph.D. Curriculum Studies<br \/> 8. M.Phil.\/Ph.D. Geography Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">9. MPhil\/PhD.<span style=\"mso-spacerun: yes;\">\u00a0 <\/span>Home Economics<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">10. MPhil\/Ph.D. Computer Science Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">11. MPhil\/Ph.D. Technology Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">Areas of specialization:<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">Building Technology<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">Electrical\/Electronic Technology<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">Mechanical Technology<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">12. M.Sc. Ed. Biology Education<br \/> 13. M.Sc. Ed. Chemistry Education<br \/> 14. M.Sc. Ed. Physics Education<br \/> 15. M.Sc. Ed. Educational Technology<br \/> 16. M.Sc. Ed. Mathematics Education<br \/> 17. M.Sc. Ed. Geography Education<br \/> 18. M.Sc. Ed. Science Education<br \/> 19. M.Sc. Ed. Curriculum Studies<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">20. M.Sc. Ed Technology Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">21. M.Sc. Ed. Computer Science Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">22. M.Sc. Ed. Home Economics<\/span><\/p>\r\n<p class=\"MsoListParagraph\" style=\"margin-left: 0cm; mso-add-space: auto; text-align: justify; line-height: 150%;\"><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">23. <\/span><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif;\">Postgraduate Diploma in Computer Science Education (PGDCSE) <\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\">Areas of specialisation:<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-weight: normal;\">Building Technology<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-weight: normal;\">Electrical\/Electronic Technology<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-weight: normal;\">Mechanical Technology<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">Home Economics Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">Child development<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">Home Management<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">Clothing Textile<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">Food nutrition and Meal Management<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">Hospitality and institutional Management<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">Building\/Woodwork Technology<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">Electrical\/Electronic Technology<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">Metal Work\/Automobile Technology<\/span><\/p>\r\n<p>\u00a0<\/p>"},{"icon":"","title":"FACULTY OF ENGINEERING","content":"<p>\u00a0<\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">A.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0 <\/span><\/span><\/span><\/strong><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif;\">DEPARTMENT OF CIVIL ENGINEERING<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"text-indent: -18.0pt; line-height: 106%; mso-list: l2 level1 lfo2;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-GB;\"><span style=\"mso-list: Ignore;\">1.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\">PGD Civil Engineering<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"text-indent: -18.0pt; line-height: 106%; mso-list: l2 level1 lfo2;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-GB;\"><span style=\"mso-list: Ignore;\">2.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\">M.Sc. Geotechnical Engineering<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"text-indent: -18.0pt; line-height: 106%; mso-list: l2 level1 lfo2;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-GB;\"><span style=\"mso-list: Ignore;\">3.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\">M.Sc. Structural Engineering<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"text-indent: -18.0pt; line-height: 106%; mso-list: l2 level1 lfo2;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-GB;\"><span style=\"mso-list: Ignore;\">4.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\">M.Sc. Water Resources and Environmental Engineering<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"text-indent: -18.0pt; line-height: 106%; mso-list: l2 level1 lfo2;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-GB;\"><span style=\"mso-list: Ignore;\">5.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\">M.Phil.\/PhD Geotechnical Engineering<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"text-indent: -18.0pt; line-height: 106%; mso-list: l2 level1 lfo2;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-GB;\"><span style=\"mso-list: Ignore;\">6.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\">M.Phil.\/PhD Structural Engineering<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"text-indent: -18.0pt; line-height: 106%; mso-list: l2 level1 lfo2;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-GB;\"><span style=\"mso-list: Ignore;\">7.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\">M.Phil.\/PhD Water Resources and Environmental Engineering<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"text-indent: -18.0pt; line-height: 106%; mso-list: l2 level1 lfo2;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-GB;\"><span style=\"mso-list: Ignore;\">8.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\">M.Phil.\/PhD Civil Engineering<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"line-height: 106%;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">B.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0 <\/span><\/span><\/span><\/strong><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif;\">DEPARTMENT OF ELECTRICAL \/ ELECTRONICS ENGINEERING<\/span><\/strong><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-size: 14.0pt;\"><span style=\"mso-spacerun: yes;\">\u00a0 \u00a0 \u00a0<\/span><\/span><span lang=\"EN-GB\" style=\"font-size: 14pt;\">\u00a0<\/span><span lang=\"EN-GB\" style=\"font-size: 14pt;\">1. PGD <a name=\"_Hlk176516574\"><\/a>Power and Machines<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-size: 14pt;\">\u00a0\u00a0\u00a0\u00a0\u00a0 2. PGD <a name=\"_Hlk176516600\"><\/a>Computer Engineering<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-size: 14pt;\">\u00a0\u00a0\u00a0\u00a0\u00a0 3. PGD <a name=\"_Hlk176516616\"><\/a>Electronics and Telecommunication<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-size: 14pt;\">\u00a0\u00a0\u00a0\u00a0\u00a0 4. M.Sc. Power and Machines<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-size: 14pt;\">\u00a0\u00a0\u00a0\u00a0\u00a0 5. M.Sc. Computer Engineering<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-size: 14pt;\">\u00a0\u00a0\u00a0\u00a0\u00a0 6. M.Sc. Electronics and Telecommunication<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-size: 14.0pt;\">\u00a0\u00a0\u00a0\u00a0\u00a0 7<\/span><span lang=\"EN-GB\" style=\"font-size: 14pt;\">. M.Phil.\/PhD Power and Machines<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-size: 14pt;\">\u00a0 \u00a0\u00a0\u00a0\u00a08. M.Phil.\/PhD Computer Engineering<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"text-indent: -18.0pt; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-GB;\">1.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0<\/span><\/span><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\">M.Phil.\/PhD Electronics and Telecommunication<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"text-indent: -18.0pt; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-GB;\">2.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB; mso-bidi-font-weight: bold; mso-bidi-font-style: italic;\">M.Phil)\/ Ph.D.\u00a0 Electrical\/Electronic\/Computer Engineering<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"text-indent: -18.0pt; mso-list: l2 level1 lfo2;\"><strong><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-GB;\"><span style=\"mso-list: Ignore;\">C.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0 <\/span><\/span><\/span><\/strong><strong><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\">DEPARTMENT OF MECHANICAL ENGINEERING<\/span><\/strong><\/p>\r\n<p class=\"MsoNormalCxSpFirst\" style=\"margin-left: 18.0pt; mso-add-space: auto;\"><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\">1. PGD Mechanical Engineering<\/span><\/p>\r\n<p class=\"MsoNormalCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; line-height: normal;\"><span lang=\"EN-GB\" style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>2. <span style=\"mso-bidi-font-weight: bold; mso-bidi-font-style: italic;\">M.Sc. Mechanical Engineering<\/span><\/span><\/p>\r\n<p class=\"MsoNormalCxSpMiddle\"><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>3. M.Sc. Energy Engineering<\/span><\/p>\r\n<p class=\"MsoNormalCxSpMiddle\" style=\"margin-left: 18.0pt; mso-add-space: auto;\"><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\">4. M.Sc. Industrial and Production Engineering<\/span><\/p>\r\n<p class=\"MsoNormalCxSpMiddle\" style=\"margin-left: 18.0pt; mso-add-space: auto;\"><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\">5. M.Phil.\/PhD Energy Engineering<\/span><\/p>\r\n<p class=\"MsoNormalCxSpMiddle\" style=\"margin-left: 18.0pt; mso-add-space: auto;\"><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\">6. M.Phil.\/PhD Industrial and Production Engineering<\/span><\/p>\r\n<p class=\"MsoNormalCxSpMiddle\"><span lang=\"EN-GB\" style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-ansi-language: EN-GB;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>7. MPhil\/PhD. <\/span><span style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-bidi-font-weight: bold; mso-bidi-font-style: italic;\">Mechanical Engineering<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"tab-stops: 48.9pt;\"><span style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">\u00a0<\/span><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">D.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0 <\/span><\/span><\/span><\/strong><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif;\">DEPARTMENT OF MINING ENGINEERING<\/span><\/strong><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-size: 14.0pt;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><span lang=\"EN-GB\" style=\"font-size: 14.0pt; font-weight: normal;\">1. Postgraduate Diploma in Mining Engineering<span style=\"mso-spacerun: yes;\">\u00a0 <\/span><\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-size: 14.0pt; font-weight: normal;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0 <\/span>2. M.Sc. Mining Engineering<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-size: 14.0pt; font-weight: normal;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0 <\/span>3. <\/span><span lang=\"EN-GB\" style=\"font-size: 14.0pt; font-weight: normal; mso-bidi-font-weight: bold;\">M.Phil\/PhD Mining Engineering<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-size: 14.0pt; font-weight: normal; mso-bidi-font-weight: bold;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><span lang=\"EN-GB\" style=\"font-size: 14.0pt; mso-bidi-font-weight: bold;\">Areas of specialization are:<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-indent: -36.0pt; line-height: 105%; mso-list: l0 level1 lfo1; tab-stops: 48.9pt;\"><!-- [if !supportLists]--><span style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">(I)<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0<\/span><\/span><\/span><span style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif;\">Surface Mining Engineering<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-indent: -36.0pt; line-height: 105%; mso-list: l0 level1 lfo1; tab-stops: 48.9pt;\"><!-- [if !supportLists]--><span style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">(II)<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif;\">Underground Mining Engineering<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-left: 72.0pt; mso-add-space: auto; text-indent: -36.0pt; line-height: 105%; mso-list: l0 level1 lfo1; tab-stops: 48.9pt;\"><!-- [if !supportLists]--><span style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">(III)<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 14.0pt; line-height: 105%; font-family: 'Times New Roman',serif;\">Rock Mechanics Engineering<\/span><\/p>\r\n<p>\u00a0<\/p>"},{"icon":"","title":"FACULTY OF ENVIRONMENTAL SCIENCES","content":"<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><strong>DEPARTMENT OF ARCHITECTURE<\/strong><\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">1. Masters of Science (M.Sc.) Architecture by research<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">2. Masters of Science (M.Sc.) Architecture by design<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">3. Doctor of Philosophy (PhD.) Architecture by research<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">4. Doctor of Architecture (PhD.) by design<\/span><\/p>\r\n<p class=\"MsoNoSpacing\" style=\"line-height: 115%;\"><strong><span style=\"font-size: 14.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">2. Department of Building<\/span><\/strong><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><br \/> a. M.Phil\/Ph.D. in Construction Management<br \/> b. M.Phil\/Ph.D. Construction Technology<\/span><\/p>\r\n<p class=\"MsoNoSpacing\" style=\"line-height: 115%;\"><span style=\"font-size: 12.0pt; line-height: 115%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">c. M.Sc. Construction Management<br \/> d. M.Sc. Construction Technology<\/span><\/p>\r\n<p class=\"MsoNoSpacing\" style=\"text-align: justify; line-height: 115%;\"><span style=\"font-family: 'Times New Roman',serif;\">\u00a0<\/span>3. DEPARTMENT OF ESTATE MANAGEMENT<\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-weight: normal;\">1. Postgraduate Diploma in Estate Management<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-weight: normal;\">2. M. Sc. Property Development and Management<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-weight: normal;\">3. M.Sc. Housing Studies<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-weight: normal;\">4. M.Sc. Property Valuation and Approval<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-weight: normal;\">5. M.Sc. Land Management<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-weight: normal;\">6. M. Phil\/PhD Valuation and Appraisal<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-weight: normal;\">7. M. Phil\/PhD Property Development and Management<\/span><\/p>\r\n<p class=\"SS1\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif;\">4. <\/span><\/strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><span style=\"mso-spacerun: yes;\">\u00a0<\/span><strong>DEPARTMENT OF GEOGRAPHY AND PLANNING<\/strong><\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"> 1. M.Phil\/Ph.D Environmental and Resources Planning (ERP)<br \/> 2. M.Phil\/Ph.D Population and Man Power Planning (PMP)<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">3. MPhil\/Ph.d Geography (with options<span style=\"mso-spacerun: yes;\">\u00a0 <\/span>in Climatology)<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">4. MPhil\/Ph.d Geography (with options<span style=\"mso-spacerun: yes;\">\u00a0 <\/span>in Geomorphology)<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">5. MPhil\/Ph.d Geography (with options<span style=\"mso-spacerun: yes;\">\u00a0 <\/span>in Transportation)<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">6. MPhil\/Ph.d Geography (with options<span style=\"mso-spacerun: yes;\">\u00a0 <\/span>in Population)<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">7. M.Sc. Environmental and Resources Planning (ERP)<br \/> 8. M.Sc. Population and Man Power Planning (PMP)<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">9. M.Sc. Geography (with options<span style=\"mso-spacerun: yes;\">\u00a0 <\/span>in Climatology)<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">10. M.Sc. Geography (with options<span style=\"mso-spacerun: yes;\">\u00a0 <\/span>in Geomorphology)<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">11. M.Sc. Geography (with options<span style=\"mso-spacerun: yes;\">\u00a0 <\/span>in Transportation)<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">12. M.Sc. Geography (with options<span style=\"mso-spacerun: yes;\">\u00a0 <\/span>in Population)<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">13. PGD Tourism and Recreation Management<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">14. PGD Geographic Information Systems (GIS)<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">15. PGD Environmental Resources Management<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"mso-bidi-font-weight: bold;\">5. <\/span><span lang=\"EN-GB\" style=\"mso-fareast-language: EN-GB;\">DEPARTMENT OF QUANTITY SURVEYING<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"mso-fareast-language: EN-GB;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><span lang=\"EN-GB\" style=\"mso-fareast-language: EN-GB; font-weight: normal;\">1. Postgraduate Programmes in Quantity Surveying<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"mso-fareast-language: EN-GB; font-weight: normal;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0 <\/span>2. Master of Science Degree in Quantity Surveying <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">\u00a0<\/span><\/strong><strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">6. DEPARTMENT OF URBAN AND REGIONAL PLANNING<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"> <span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0 <\/span>1. M.Phil\/Ph.D. Urban and Regional Planning<br \/> <span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0 <\/span>2. M.Sc. Urban and Regional Planning<br \/> <span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0 <\/span>3. Postgraduate Diploma Urban and Regional Planning<\/span><\/p>"},{"icon":"","title":"FACULTY OF HEALTH SCIENCES AND TECHNOLOGY","content":"<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><strong><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">A. <\/span><\/strong><strong><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">Department Of Medical Laboratory Science<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; text-indent: -22.5pt; line-height: normal; margin: 0cm 0cm .0001pt 22.5pt;\"><strong><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">1. \u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/strong><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">Postgraduate Diploma MLS (Histopathology)<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; text-indent: -22.5pt; line-height: normal; margin: 0cm 0cm .0001pt 22.5pt;\"><strong><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">2. \u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/strong><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">Postgraduate Diploma MLS (Chemical Pathology) <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: 6.0pt; text-align: justify; line-height: normal;\"><strong><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">3. <\/span><\/strong><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">MSc. MLS Medical Microbiology (Medical Parasitology, Medical Bacteriology, Medical Virology &\u00a0\u00a0\u00a0 Medical Mycology)<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: 6.0pt; text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">4. MSc MLS Haematology & blood transfusion science<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: 6.0pt; text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">5. MSc. MLS Chemical pathology<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: 6.0pt; text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">6. MSc. MLS Histopathology<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">7. MSc. MLS Immunology and immunochemistry<\/span><\/p>\r\n<p class=\"MsoListParagraph\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\">8.<\/span><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\"><span style=\"font-family: 'Times New Roman'; font-size: xx-small;\">\u00a0<\/span><\/span><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">MPhil\/PhD. MLS Medical Microbiology (Medical Parasitology, Medical Bacteriology, Medical Virology &\u00a0 Medical Mycology)<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: 6.0pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l1 level1 lfo2;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\">9.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">MPhil\/PhD MLS Haematology & blood transfusion science<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: 6.0pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\">1.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">MPhil\/PhD MLS Chemical pathology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: 6.0pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\">2.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">MPhil\/PhD MLS Histopathology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; letter-spacing: -.5pt;\">3.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">MPhil\/PhD MLS Immunology and immunochemistry<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: 3.0pt; text-align: justify; line-height: 150%;\"><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; letter-spacing: -.5pt;\">\u00a0<\/span><strong><span style=\"font-size: 16.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">2. DEPARTMENT OF NURSING <\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">1. MSc Medical and Surgical Nursing <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">2. MSc Psychiatric\/Mental Health Nursing<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">3. MSc Community Health Nursing <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">4. MSc Maternal and Child Health Nursing<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">5. MSc Nursing Education<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">6. MSc Health and Nursing Administration<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">7. M.Phil\/PhD Medical and Surgical Nursing <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">8. M.Phil\/PhD Psychiatric\/Mental Health Nursing<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">9. M.Phil\/PhD Community Health Nursing <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">10. M.Phil\/PhD Maternal and Child Health Nursing<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">11. M.Phil\/PhD Nursing Education<\/span><\/p>\r\n<p><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-US; mso-fareast-language: EN-US; mso-bidi-language: AR-SA;\">12. M.Phil\/PhD Health and Nursing Administration<\/span><\/p>"},{"icon":"","title":"FACULTY OF LAW","content":"<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; mso-bidi-font-size: 11.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">1. LL.M. (Taxation Law and Policy)<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-right: 183.2pt; text-align: justify;\"><span style=\"font-size: 12.0pt; mso-bidi-font-size: 11.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">2. LL.M. (Energy and Natural Resources Law)<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-right: 183.2pt; text-align: justify;\"><span style=\"font-size: 12.0pt; mso-bidi-font-size: 11.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">3. LL.M. (Intellectual Property Law and Policy)<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-right: 183.2pt; text-align: justify;\"><span style=\"font-size: 12.0pt; mso-bidi-font-size: 11.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">4. LL.M. (International Law and Diplomacy)<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-right: 183.2pt; text-align: justify;\"><span style=\"font-size: 12.0pt; mso-bidi-font-size: 11.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">5. LL.M. (Law of Alternative Dispute Resolution)<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-right: 183.2pt; text-align: justify;\"><span style=\"font-size: 12.0pt; mso-bidi-font-size: 11.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">6. LL.M. (Constitutional and Human Rights Law)<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-right: 183.2pt; text-align: justify;\"><span style=\"font-size: 12.0pt; mso-bidi-font-size: 11.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">7. LL.M. (Law)<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-right: 183.2pt; text-align: justify;\"><span style=\"font-size: 12.0pt; mso-bidi-font-size: 11.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\">8. MPhil\/PhD. Law<\/span><\/p>\r\n<p><span style=\"font-size: 12.0pt; mso-bidi-font-size: 11.0pt; line-height: 106%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 1.0pt; mso-ligatures: standardcontextual; mso-ansi-language: EN-US; mso-fareast-language: EN-US; mso-bidi-language: AR-SA;\">9. MPhil\/PhD Law and Diplomacy<\/span><\/p>"},{"icon":"","title":"FACULTY OF MANAGEMENT SCIENCES","content":"<p class=\"SS1\" style=\"text-align: left;\" align=\"left\"><span lang=\"EN-GB\" style=\"font-family: 'Calibri Light',sans-serif;\">A. DEPARTMENT OF ACCOUNTING AND FINANCE<br \/> <br \/> <\/span><span lang=\"EN-GB\" style=\"font-weight: normal;\">1. M.Sc. Accounting and Finance<\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-family: 'Calibri Light',sans-serif; font-weight: normal;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>2. M.Sc. Forensic Accounting <\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-family: 'Calibri Light',sans-serif; font-weight: normal;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>3. MPhil\/PhD Accounting <\/span><\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\" style=\"font-family: 'Calibri Light',sans-serif; font-weight: normal;\">\u00a0<\/span>B. DEPARTMENT OF ACTUARIAL SCIENCE<\/p>\r\n<p class=\"SS2\" style=\"margin-left: 0cm; text-indent: 0cm;\"><span lang=\"EN-GB\" style=\"font-weight: normal;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>1. Postgraduate Diploma in Actuarial Science<\/span><\/p>\r\n<p class=\"SS2\"><span lang=\"EN-GB\" style=\"font-weight: normal;\"><span style=\"mso-spacerun: yes;\">\u00a0<\/span>2. Masters of Science (M.Sc.) in Actuarial Science<\/span><\/p>\r\n<p class=\"SS2\"><span lang=\"EN-GB\" style=\"font-weight: normal;\">\u00a0<\/span><strong><span style=\"font-size: 14.0pt; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><span style=\"mso-spacerun: yes;\">\u00a0 \u00a0\u00a0<\/span>c. Department of Business Administration<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"> <strong><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/strong><span style=\"mso-bidi-font-weight: bold;\">1. <\/span>M.Phil.\/Ph.D. Management<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; mso-bidi-font-weight: bold;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>2. M.Sc. Management<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: normal;\"><span style=\"font-size: 12.0pt; mso-bidi-font-weight: bold;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>3. Postgraduate Diploma in Management (PGDM)<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: normal;\">\u00a0<span style=\"font-size: 12.0pt; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><span style=\"mso-spacerun: yes;\">\u00a0 \u00a0<\/span><span style=\"mso-spacerun: yes;\">\u00a0<\/span><\/span><strong><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">D. DEPARTMENT OF BANKING AND FINANCE<\/span><\/strong><\/p>\r\n<p class=\"MsoNoSpacing\" style=\"margin-left: 32.2pt; text-align: justify; text-indent: -18.0pt; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">1.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">PGD Banking and Finance<\/span><\/p>\r\n<p class=\"MsoNoSpacing\" style=\"margin-left: 32.2pt; text-align: justify; text-indent: -18.0pt; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">2.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">M.Sc. Banking and Finance<\/span><\/p>\r\n<p class=\"MsoNoSpacing\" style=\"margin-left: 32.2pt; text-align: justify; text-indent: -18.0pt; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">3.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">MPhil.\/Ph.D. Banking and Finance<\/span><\/p>\r\n<p class=\"MsoNoSpacing\" style=\"text-align: justify;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0<\/span>E. DEPARTMENT OF MARKETING<\/p>\r\n<p class=\"SS2\"><span lang=\"EN-PH\" style=\"font-size: 13.5pt; color: black; mso-ansi-language: EN-PH; mso-fareast-language: EN-PH; font-weight: normal;\">1. PGD Marketing<\/span><\/p>\r\n<p class=\"SS2\"><span lang=\"EN-PH\" style=\"font-size: 13.5pt; color: black; mso-ansi-language: EN-PH; mso-fareast-language: EN-PH; font-weight: normal;\">2. MSc. Marketing<\/span><\/p>\r\n<p class=\"SS2\"><span lang=\"EN-PH\" style=\"font-size: 13.5pt; color: black; mso-ansi-language: EN-PH; mso-fareast-language: EN-PH; font-weight: normal;\">3. MPhil\/PhD Marketing<\/span><\/p>\r\n<p class=\"SS2\"><span lang=\"EN-PH\" style=\"font-size: 13.5pt; color: black; mso-ansi-language: EN-PH; mso-fareast-language: EN-PH; font-weight: normal;\">\u00a0<\/span>F. DEPARTMENT OF INSURANCE<\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: 115%;\"><span style=\"font-size: 12.0pt; line-height: 115%; mso-bidi-font-weight: bold;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>1. PGD Insurance<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: 115%;\"><span style=\"font-size: 12.0pt; line-height: 115%; mso-bidi-font-weight: bold;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>2. MSc. Insurance & Risk Management<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: 115%;\"><span style=\"font-size: 12.0pt; line-height: 115%; mso-bidi-font-weight: bold;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>3. MPhil\/PhD Insurance & Risk Management<\/span><\/p>"},{"icon":"","title":"FACULTY OF NATURAL SCIENCES","content":"<p class=\"MsoNormal\" style=\"line-height: normal;\"><strong><span style=\"font-size: 12.0pt; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">A. DEPARTMENT OF COMPUTER SCIENCE <\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">1. Postgraduate Diploma in Computer Science <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">2. M.Sc. Computer Science Programme<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">3. MPhil\/ Ph.D. Computer Science\u00a0 <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"line-height: normal;\"><span class=\"MsoPageNumber\"><strong><span style=\"font-size: 12.0pt; font-family: 'Calibri',sans-serif; mso-ascii-theme-font: minor-latin; mso-hansi-theme-font: minor-latin; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">B. DEPARTMENT OF GEOLOGY<\/span><\/strong><\/span><span class=\"MsoPageNumber\"><span style=\"font-family: 'Calibri',sans-serif; mso-ascii-theme-font: minor-latin; mso-hansi-theme-font: minor-latin; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><br \/> 1. M.Phil\/Ph.D. Ore Geology<br \/> 2. M.Phil\/Ph.D. Geochemistry<\/span><\/span><span style=\"font-size: 12.0pt; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><br \/> 3. M.Phil\/Ph.D. Environmental Geology<br \/> 4. M.Phil\/Ph.D. Hydrogeology and Engineering Geology<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">5. M.Sc. Mineral Exploration and Mining Geology<br \/> 6. M.Sc. Engineering Geology and Hydrogeology<br \/> 7. M.Sc. Petroleum and Geology\/Sedimentology<br \/> 8. M.Sc. Environmental Geology<br \/> 9. Postgraduate Diploma in Environmental Geology (PDEG)<br \/> 10. Postgraduate Diploma in Mining Geology (PDMG) <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"line-height: normal;\"><strong><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">C. Department of Science Laboratory Technology<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><strong><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0\u00a0\u00a0 <\/span><\/strong><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">1<\/span><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">. <\/span><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">M.Sc. Biological Sciences Techniques <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: 150%;\"><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0\u00a0\u00a0\u00a0 2. M.Sc. Biochemistry Techniques <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: 150%;\"><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0\u00a0 \u00a0\u00a03.\u00a0 M.Sc. Chemical Sciences \/Petroleum Techniques<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: 150%;\"><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0\u00a0\u00a0 \u00a04. M.Sc. Geology Techniques<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; text-align: justify; line-height: 150%;\"><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0\u00a0\u00a0\u00a0 5. M.Sc. Microbiology Techniques<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"margin-bottom: 10.0pt; mso-add-space: auto; text-indent: -36.0pt; mso-text-indent-alt: -18.0pt; line-height: 150%; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>1.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">M.Phil\/Ph.D Degree in Science Laboratory Technology (Biological Sciences Techniques)<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: 10.0pt; mso-add-space: auto; text-indent: -36.0pt; mso-text-indent-alt: -18.0pt; line-height: 150%; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>2.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">M.Phil\/Ph.D Degree in Science Laboratory Technology (Biochemistry Techniques)<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: 10.0pt; mso-add-space: auto; text-indent: -36.0pt; mso-text-indent-alt: -18.0pt; line-height: 150%; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>3.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">M.Phil\/Ph.D Degree in Science Laboratory Technology (Microbiology Techniques)<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: 10.0pt; mso-add-space: auto; text-indent: -36.0pt; mso-text-indent-alt: -18.0pt; line-height: 150%; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>4.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">M.Phil\/Ph.D Degree in Science Laboratory Technology (Chemical Sciences \/Petroleum Techniques)<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-bottom: 10.0pt; mso-add-space: auto; text-indent: -36.0pt; mso-text-indent-alt: -18.0pt; line-height: 150%; mso-list: l0 level1 lfo1;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>5.<span style=\"font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-size-adjust: none; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-variant-emoji: normal; font-stretch: normal; font-size: 7pt; line-height: normal; font-family: 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">M.Phil\/Ph.D Degree in Science Laboratory Technology (Geology Techniques)<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: 10.0pt; line-height: 150%;\"><strong><span style=\"font-size: 14.0pt; line-height: 150%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">D. Department of Physics<\/span><\/strong><span style=\"font-size: 12.0pt; line-height: 150%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><br \/> <\/span><span class=\"MsoPageNumber\"><span style=\"font-family: 'Calibri',sans-serif; mso-ascii-theme-font: minor-latin; mso-hansi-theme-font: minor-latin; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">1.\u00a0 M.Phil\/Ph.D. Acoustics<br \/> 2. \u00a0M.Phil\/Ph.D. Atmospheric Physics<br \/> 3. \u00a0M.Phil\/Ph.D. Electronic and Telecommunication<br \/> 4. M.Phil\/Ph.D. Geophysics<\/span><\/span><\/p>\r\n<p class=\"MsoNormal\"><span class=\"MsoPageNumber\"><span style=\"font-family: 'Calibri',sans-serif; mso-ascii-theme-font: minor-latin; mso-hansi-theme-font: minor-latin; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">5. \u00a0M.Phil\/Ph.D. Medical\/Radiation Biophysics<\/span><\/span><\/p>\r\n<p class=\"MsoNormal\"><span class=\"MsoPageNumber\"><span style=\"font-family: 'Calibri',sans-serif; mso-ascii-theme-font: minor-latin; mso-hansi-theme-font: minor-latin; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">6. M.Phil\/Ph.D. Theoretical Physics<br \/> 7. M.Sc. Pure Physics<br \/> 8. M.Sc. Applied Physics<\/span><\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">9. Postgraduate Diploma in Electronics and Physics<\/span><\/p>\r\n<p class=\"MsoNormal\"><strong><span style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">E. Department of Chemistry<\/span><\/strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><br \/> 1. M.Phil\/Ph.D. Applied Analytical Chemistry<br \/> 2. M.Phil\/Ph.D. Applied Inorganic Chemistry<br \/> 3. M.Phil\/Ph.D. Applied Organic Chemistry<br \/> 4. M.Phil\/Ph.D. Applied Physical Chemistry<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">5. M.Sc. Applied Analytical Chemistry<br \/> 6. M.Sc. Applied Inorganic Chemistry<br \/> 7. M.Sc. Applied Organic Chemistry<br \/> 8. M.Sc. Applied Physical Chemistry<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">9. Postgraduate Diploma in Environmental and Industrial Chemistry<br \/> <br \/> <\/span><strong><span style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">F. Department of Plant Science and Technology<\/span><\/strong><strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><br \/> <\/span><\/strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">1. M.Phil\/Ph.D Phycology and Aquatic Plants<br \/> 2. M.Phil\/Ph.D Plant Physiology<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">3. M.Phil\/Ph.D Plant Anatomy<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">4. M.Phil\/Ph.D Plant Ecology<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">5. M.Phil\/Ph.D Plant Pathology<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">6. M.Phil\/Ph.D Plant Taxonomy<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">7. M.Phil\/Ph.D Medicinal Botany<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">8. M.Phil\/Ph.D\u00a0 Cytogenetic and Plant Breeding<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">9. M.Phil\/Ph.D Applied Microbiology<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">10. MPhil\/PhD. Plant Biotechnology<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">11. M.Sc. Phycology and Aquatic Plants<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">12. M.Sc. Plant Physiology<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">13. M.Sc. Plant Anatomy<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">14. M.Sc. Plant Ecology<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">15. M.Sc. Plant Pathology<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">16. M.Sc. Taxonomy and Systematics<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">17. M.Sc. Medicinal Botany<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">18. M.Sc. cytogenic and Plant Breeding<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">19. M.Sc. Applied Microbiology and Plant Pathology<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">20. M.Sc. Plant Biotechnology<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">21. Postgraduate Diploma (PGD) Plant Biotechnology<\/span><\/p>\r\n<p class=\"MsoNormal\"><strong><span style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">G. Department of Zoology<\/span><\/strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><br \/> 1. M.Phil\/Ph.D. Entomology (with specialization in Entomology (Medical, Agricultural and General),<br \/> 2. M.Phil\/Ph.D. Parasitology(Medical, Veterinary and General)<br \/> 3. M.Phil\/Ph.D. Applied Hydrobiology and Fisheries<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">4. M.Sc. Applied Entomology and Parasitology<br \/> 5. M.Sc. Applied Hydrobiology and Fisheries<br \/> 6. M.Sc. Conservation Biology<\/span><\/p>\r\n<p class=\"MsoNormal\"><strong><span style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">H. Department of Microbiology<\/span><\/strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><br \/> 1. M.Phil\/Ph.D Microbial Biotechnology<br \/> 2. M.Phil\/Ph.D Food and Industrial Microbiology<br \/> 3. M.Phil\/Ph.D Environmental Microbiology<br \/> 4. M.Phil\/Ph.D Public Health and Sanitary Microbiology<br \/> 5. M.Phil\/Ph.D Medical Microbiology and Immunology<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">6. M.Sc. Microbial Biotechnology<br \/> 7. M.Sc. Food and Industrial Microbiology<br \/> 8. M.Sc. Environmental Microbiology<br \/> 9. M.Sc. Public Health and Sanitary Microbiology<br \/> 10. M.Sc. Medical Microbiology and Immunology<\/span><\/p>\r\n<p><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-US; mso-fareast-language: EN-US; mso-bidi-language: AR-SA;\">11. Postgraduate Diploma in Microbiology<br \/> <br \/> <\/span><strong><span style=\"font-size: 14.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-US; mso-fareast-language: EN-US; mso-bidi-language: AR-SA;\">I. Department of Mathematics<\/span><\/strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-US; mso-fareast-language: EN-US; mso-bidi-language: AR-SA;\"><br \/> <strong>M.Phil\/Ph.D Programmes<\/strong>:<br \/> 1. M.Phil\/Ph.D. Abstract Algebra<br \/> 2. M.Phil\/Ph.D. Numerical Analysis<br \/> 3. M.Phil\/Ph.D. Biomathematics<br \/> 4. M.Phil\/Ph.D. Control Theory<br \/> 5. M.Sc. Abstract Algebra<br \/> 6. M.Sc. Numerical Analysis<br \/> 7. M.Sc. Biomathematics<br \/> 8. M.Sc. Control Theory<br \/> <!-- [if !supportLineBreakNewLine]--><br \/> <!--[endif]--><\/span><\/p>"},{"icon":"","title":"FACULTY OF SOCIAL SCIENCES","content":"<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">1. DEPARTMENT OF ECONOMICS<\/span><\/strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><br \/> 1. M.Phil\/Ph.D Economics<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">2. M.Sc. Economics<br style=\"mso-special-character: line-break;\" \/> <!-- [if !supportLineBreakNewLine]--><br style=\"mso-special-character: line-break;\" \/> <!--[endif]--><\/span><\/p>\r\n<p class=\"MsoNormal\"><strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">2. DEPARTMENT OF GENERAL AND APPLIED PSYCHOLOGY<\/span><\/strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><br \/> 1. M.Phil\/Ph.D. Clinical Psychology<br \/> 2. M.Phil\/Ph.D. Organizational Psychology<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">3.<\/span><span lang=\"FR\" style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none; mso-ansi-language: FR;\"> M.Sc. Clinical Psychology<br \/> 4. M.Sc. Organizational Psychology<br \/> 5. <\/span><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">M.Sc. Social and Terrorism Psychology<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">6. M.Sc. Counselling Psychology<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">7. Postgraduate Diploma in Psychology<\/span><span style=\"mso-ascii-font-family: Calibri; mso-fareast-font-family: 'Times New Roman'; mso-hansi-font-family: Calibri; mso-bidi-font-family: Calibri; mso-font-kerning: 0pt; mso-ligatures: none;\"><br \/> <\/span><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><br \/> <strong>3. DEPARTMENT OF POLITICAL SCIENCE<\/strong><br \/> 1. M.Phil\/Ph.D. International Relations<br \/> 2. M.Phil\/Ph.D. Political Economy and Development Studies<br \/> 3. M.Phil\/Ph.D. Public Administration.<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">4. M.Sc. International Relations and Strategic Studies<br \/> 5. M.Sc. Political Economy and Development Studies<br \/> 6. M.Sc. Public Policy and Administration.<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">7. Master of Research and Public Policy (MRPP)<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\"><strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">4. Department of Sociology<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\">1. <span style=\"mso-spacerun: yes;\">\u00a0<\/span>Postgraduate Diploma (PGD) in Social Work<\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt;\">2. <span style=\"font-size: 12.0pt; line-height: 106%;\">M.Sc. Sociology<\/span> <span style=\"mso-spacerun: yes;\">\u00a0<\/span>(with Specialization in Criminology, Medical Sociology, Sociology of Development, <span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0<\/span>Industrial Sociology, etc.)<span style=\"mso-spacerun: yes;\">\u00a0 <\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify; line-height: 150%;\"><span lang=\"EN-GB\" style=\"font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-bidi-font-weight: bold;\">3.<strong> <span style=\"mso-spacerun: yes;\">\u00a0<\/span><\/strong><\/span><span lang=\"EN-GB\">M.Sc. Social Work (MSSW)<\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify; line-height: 150%; tab-stops: 114.0pt;\"><span lang=\"EN-GB\">4. MPhil\/PhD Sociology<\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify; line-height: 150%; tab-stops: 114.0pt;\"><span lang=\"EN-GB\">5. MPhil\/PhD Social Work<\/span><span lang=\"EN-GB\" style=\"color: windowtext;\">. <\/span><\/p>"},{"icon":"","title":"FACULTY OF PHARMACEUTICAL SCIENCES","content":"<p class=\"MsoNoSpacing\"><strong style=\"mso-bidi-font-weight: normal;\"><em style=\"mso-bidi-font-style: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">1.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><\/em><\/strong><strong style=\"mso-bidi-font-weight: normal;\"><em style=\"mso-bidi-font-style: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">DEPARTMENT OF PHARMACEUTICAL AND MEDICINAL CHEMISTRY<\/span><\/em><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-bottom: .0001pt; mso-add-space: auto; line-height: normal;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 6.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"line-height: normal; margin: 0cm 0cm .0001pt 36.0pt;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><span style=\"mso-spacerun: yes;\">\u00a0<\/span>1. Post Graduate Diploma in Pharmaceutical Chemistry <\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>2. M.Sc. Pharmaceutical Chemistry<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>3. M.Sc. Bioinformatics and Genomics<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"margin-bottom: .0001pt; mso-add-space: auto; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><span style=\"mso-spacerun: yes;\">\u00a0<\/span>4. M.Phil\/Ph.D Pharmaceutical Chemistry<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"mso-add-space: auto; line-height: normal; margin: 0cm 0cm .0001pt 3.0cm;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 6.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0<\/span><\/strong><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"line-height: normal; margin: 0cm 0cm .0001pt 14.2pt;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">2. DEPARTMENT OF PHARMACEUTICAL TECHNOLOGY AND INDUSTRIAL PHARMACY<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraph\" style=\"margin-bottom: .0001pt; mso-add-space: auto; line-height: normal;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 8.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0<\/span><\/strong><span style=\"mso-spacerun: yes;\">\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u00a0<\/span>1. M.Sc. Pharmaceutical Technology<\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>2. M.Phil\/Ph.D Pharmaceutical Technology<\/span><\/p>\r\n<p class=\"MsoListParagraph\" style=\"margin-bottom: .0001pt; mso-add-space: auto; line-height: normal;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0<\/span><\/strong><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">3. DEPARTMENT OF PHARMACOGNOSY AND TRADITIONAL MEDICINE<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraph\" style=\"margin-bottom: .0001pt; mso-add-space: auto; line-height: normal;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 8.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0<\/span><\/strong><span style=\"mso-spacerun: yes;\">\u00a0 \u00a0 \u00a0 \u00a0 \u00a0<\/span>1. M.Sc. Pharmacognosy and Traditional Medicine<\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>2. M.Phil\/Ph.D Pharmacognosy and Traditional Medicine<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\">\u00a0<\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"mso-add-space: auto; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1; margin: 0cm 0cm .0001pt 32.2pt;\"><!-- [if !supportLists]--><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">1.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><\/strong><!--[endif]--><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">DEPARTMENT OF PHARMACEUTICAL MICROBIOLOGY AND BIOTECHNOLOGY<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-bottom: .0001pt; mso-add-space: auto; line-height: normal;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 8.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0<\/span><\/strong><span style=\"mso-spacerun: yes;\">\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0<\/span>1. M.Sc. Pharmaceutical Microbiology<\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>2. M.Sc. Biotechnology<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>3. M.Phil\/Ph.D Pharmaceutical Microbiology<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>4. M.Phil\/PhD Biotechnology<span style=\"mso-spacerun: yes;\">\u00a0<\/span><\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"mso-add-space: auto; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1; margin: 0cm 0cm .0001pt 32.2pt;\"><!-- [if !supportLists]--><strong style=\"mso-bidi-font-weight: normal;\"><em style=\"mso-bidi-font-style: normal;\"><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">2.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><\/em><\/strong><!--[endif]--><strong style=\"mso-bidi-font-weight: normal;\"><em style=\"mso-bidi-font-style: normal;\"><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">DEPARTMENT OF PHARMACEUTICS<\/span><\/em><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-bottom: .0001pt; mso-add-space: auto; line-height: normal;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 8.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"line-height: normal; margin: 0cm 0cm .0001pt 32.2pt;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><span style=\"mso-spacerun: yes;\">\u00a0 <\/span>1. M.Sc. Drug Delivery<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>2. M.Sc. Cosmetic Science<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>3. M.Phil\/Ph.D Drug Delivery<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>4. M.Phil\/Ph.D Cosmetic Science<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"mso-add-space: auto; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1; margin: 0cm 0cm .0001pt 32.2pt;\"><!-- [if !supportLists]--><strong style=\"mso-bidi-font-weight: normal;\"><em style=\"mso-bidi-font-style: normal;\"><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">3.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><\/em><\/strong><!--[endif]--><strong style=\"mso-bidi-font-weight: normal;\"><em style=\"mso-bidi-font-style: normal;\"><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">DEPARTMENT OF PHARMACOLOGY AND TOXICOLOGY<\/span><\/em><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; line-height: normal;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 8.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"mso-add-space: auto; text-indent: -14.15pt; line-height: normal; mso-list: l0 level4 lfo1; margin: 0cm 0cm .0001pt 3.0cm;\"><!-- [if !supportLists]--><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">1.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0 <\/span><\/span><\/span><\/strong><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">M.Sc. Pharmacology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"mso-add-space: auto; text-indent: -14.15pt; line-height: normal; mso-list: l0 level4 lfo1; margin: 0cm 0cm .0001pt 3.0cm;\"><!-- [if !supportLists]--><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">2.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0 <\/span><\/span><\/span><\/strong><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">M.Sc. Clinical Pharmacology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"mso-add-space: auto; text-indent: -14.15pt; line-height: normal; mso-list: l0 level4 lfo1; margin: 0cm 0cm .0001pt 3.0cm;\"><!-- [if !supportLists]--><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">3.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0 <\/span><\/span><\/span><\/strong><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">M.Sc. Forensic Toxicology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"mso-add-space: auto; text-indent: -14.15pt; line-height: normal; mso-list: l0 level4 lfo1; margin: 0cm 0cm .0001pt 3.0cm;\"><!-- [if !supportLists]--><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">4.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0 <\/span><\/span><\/span><\/strong><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">MPhil\/Ph.D Pharmacology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"mso-add-space: auto; text-indent: -14.15pt; line-height: normal; mso-list: l0 level4 lfo1; margin: 0cm 0cm .0001pt 3.0cm;\"><!-- [if !supportLists]--><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">5.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0 <\/span><\/span><\/span><\/strong><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">MPhil\/Ph.D Clinical Pharmacology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"mso-add-space: auto; text-indent: -14.15pt; line-height: normal; mso-list: l0 level4 lfo1; margin: 0cm 0cm .0001pt 3.0cm;\"><!-- [if !supportLists]--><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">6.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0 <\/span><\/span><\/span><\/strong><!--[endif]--><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">MPhil\/Ph.D Forensic Toxicology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"mso-add-space: auto; line-height: normal; margin: 0cm 0cm .0001pt 70.9pt;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"mso-add-space: auto; text-indent: -18.0pt; line-height: normal; mso-list: l0 level1 lfo1; margin: 0cm 0cm .0001pt 32.2pt;\"><!-- [if !supportLists]--><strong style=\"mso-bidi-font-weight: normal;\"><em style=\"mso-bidi-font-style: normal;\"><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">4.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><\/em><\/strong><!--[endif]--><strong style=\"mso-bidi-font-weight: normal;\"><em style=\"mso-bidi-font-style: normal;\"><span style=\"font-size: 14.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">DEPARTMENT OF CLINICAL PHARMACY AND PHARMACY PRACTICE<\/span><\/em><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-bottom: .0001pt; mso-add-space: auto; line-height: normal;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 8.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\">\u00a0<\/span><\/strong><span style=\"mso-spacerun: yes;\">\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u00a0<\/span><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span>1. Post Graduate Diploma (PGD) in Clinical Pharmacy and Pharmacy Practice<span style=\"mso-spacerun: yes;\">\u00a0<\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"margin-bottom: .0001pt; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span>2. M.Sc. Clinical Pharmacy and Pharmacy<\/span><\/p>\r\n<p class=\"MsoListParagraph\" style=\"margin-bottom: .0001pt; mso-add-space: auto; line-height: normal;\"><span style=\"font-size: 12.0pt; font-family: 'Times New Roman',serif; mso-bidi-font-family: 'Times New Roman'; mso-bidi-theme-font: minor-bidi;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0 <\/span><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span>3. M.Phil\/Ph.D Clinical Pharmacy and Pharmacy Practice<\/span><\/p>"},{"icon":"","title":"FACULTY OF VETERINARY MEDICINE","content":"<p class=\"Default\"><strong><span lang=\"EN-GB\">DEPARTMENT OF VETERINARY ANATOMY POSTGRADUATE PROGRAMMES<\/span><\/strong><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><span lang=\"EN-GB\" style=\"mso-bidi-font-weight: bold;\">1. Master of Science (MSc) in Veterinary Anatomy<\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><span lang=\"EN-GB\" style=\"mso-bidi-font-weight: bold;\">2. Doctor of Philosophy (PhD) in Veterinary Anatomy<\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><strong><span lang=\"EN-GB\">\u00a0<\/span><\/strong><\/p>\r\n<p class=\"Default\"><strong><span lang=\"EN-GB\">2. DEPARTMENT OF VETERINARY MICROBIOLOGY AND PATHOLOGY<\/span><\/strong><\/p>\r\n<p class=\"Default\"><strong><span lang=\"EN-GB\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0 <\/span>MICROBIOLOGY PG PROGRAMME<\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"text-align: justify; text-indent: -18.0pt; mso-list: l1 level1 lfo1; mso-layout-grid-align: none; text-autospace: none;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; line-height: 105%; mso-bidi-font-family: Calibri; mso-bidi-theme-font: minor-latin; color: black;\"><span style=\"mso-list: Ignore;\">1.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; line-height: 105%; mso-fareast-font-family: Calibri; color: black;\">MSc\/PhD in Veterinary Anatomic and Clinical Pathology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: 1.35pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l1 level1 lfo1; mso-layout-grid-align: none; text-autospace: none;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; mso-bidi-font-family: Calibri; mso-bidi-theme-font: minor-latin; color: black;\"><span style=\"mso-list: Ignore;\">2.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; mso-fareast-font-family: Calibri; color: black;\">PhD in: Bacteriology and Molecular biology <\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: 1.35pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l1 level1 lfo1; mso-layout-grid-align: none; text-autospace: none;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; mso-bidi-font-family: Calibri; mso-bidi-theme-font: minor-latin; color: black;\"><span style=\"mso-list: Ignore;\">3.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; mso-fareast-font-family: Calibri; color: black;\">MSc\/PhD in Veterinary Immunology <\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: 1.35pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l1 level1 lfo1; mso-layout-grid-align: none; text-autospace: none;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; mso-bidi-font-family: Calibri; mso-bidi-theme-font: minor-latin; color: black;\"><span style=\"mso-list: Ignore;\">4.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; mso-fareast-font-family: Calibri; color: black;\">PhD in: Veterinary Mycology <\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: 1.35pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l1 level1 lfo1; mso-layout-grid-align: none; text-autospace: none;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; mso-bidi-font-family: Calibri; mso-bidi-theme-font: minor-latin; color: black;\"><span style=\"mso-list: Ignore;\">5.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; mso-fareast-font-family: Calibri; color: black;\">MSc\/PhD in: Veterinary Virology <\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-bottom: 1.35pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l1 level1 lfo1; mso-layout-grid-align: none; text-autospace: none;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; mso-bidi-font-family: Calibri; mso-bidi-theme-font: minor-latin; color: black;\"><span style=\"mso-list: Ignore;\">6.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; mso-fareast-font-family: Calibri; color: black;\">MSc\/PhD in: Veterinary Microbiology<\/span><\/p>\r\n<p class=\"Default\"><strong style=\"mso-bidi-font-weight: normal;\"><span lang=\"EN-GB\">3. DEPARTMENT OF VETERINARY <span style=\"mso-bidi-font-weight: bold;\">PARASITOLOGY AND ENTOMOLOGY <span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/span>POSTGRADUATE CURRICULUM<\/span><\/strong><\/p>\r\n<p class=\"Default\" style=\"margin-bottom: 1.35pt; text-align: justify;\"><span lang=\"EN-GB\">1. <span style=\"mso-spacerun: yes;\">\u00a0<\/span>Veterinary Protozoology <span style=\"mso-bidi-font-style: italic;\">(MSc. Vet. Protozoology), <\/span><\/span><\/p>\r\n<p class=\"Default\" style=\"margin-bottom: 1.35pt; text-align: justify;\"><span lang=\"EN-GB\">2. Veterinary Helminthology <span style=\"mso-bidi-font-style: italic;\">(MSc. Vet. Helminthology) <\/span>and <\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><span lang=\"EN-GB\">3. Veterinary Entomology <span style=\"mso-bidi-font-style: italic;\">(MSc. Vet .Entomology)<\/span>. <\/span><\/p>\r\n<p class=\"Default\" style=\"margin-bottom: 1.35pt; text-align: justify;\"><span lang=\"EN-GB\">4. Veterinary Protozoology <em>(PhD Veterinary Protozoology), <\/em><\/span><\/p>\r\n<p class=\"Default\" style=\"margin-bottom: 1.35pt; text-align: justify;\"><span lang=\"EN-GB\">5. Veterinary Helminthology <em>(PhD Veterinary Helminthology) <\/em>and <\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><span lang=\"EN-GB\">6. Veterinary Entomology <em>(PhD Veterinary Entomology)<\/em>. <\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><span lang=\"EN-GB\">7. <span style=\"mso-bidi-font-weight: bold;\">Postgraduate Diploma In Veterinary Parasitology (PGDVP<strong>) <\/strong><\/span><\/span><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; tab-stops: 145.7pt;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 12.0pt; line-height: 106%;\">\u00a0<\/span><\/strong><\/p>\r\n<p class=\"MsoNormal\" style=\"text-align: justify; tab-stops: 145.7pt;\"><strong style=\"mso-bidi-font-weight: normal;\"><span style=\"font-size: 14.0pt; line-height: 106%;\">3.<\/span><\/strong><span style=\"font-size: 14.0pt; line-height: 106%;\"> <strong>DEPARTMENT OF VETERINARY PUBLIC HEALTH AND PREVENTIVE MEDICINE POSTGRADUATE CURRICULUM<\/strong><\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify; text-indent: -18.0pt; mso-list: l0 level1 lfo2; margin: 0cm 0cm 1.35pt 36.0pt;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">1.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span lang=\"EN-GB\" style=\"mso-bidi-font-weight: bold;\">M.Sc. <\/span><span lang=\"EN-GB\">Veterinary Public Health and Preventive Medicine <\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify; text-indent: -18.0pt; mso-list: l0 level1 lfo2; margin: 0cm 0cm 1.35pt 36.0pt;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">2.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span lang=\"EN-GB\">M.Sc. One Health<\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify; text-indent: -18.0pt; mso-list: l0 level1 lfo2; margin: 0cm 0cm 1.35pt 36.0pt;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">3.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span lang=\"EN-GB\" style=\"mso-bidi-font-weight: bold;\">MPhil\/Ph.D<span style=\"mso-spacerun: yes;\">\u00a0 <\/span>Veterinary Public Health and Preventive Medicine<\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><strong><span lang=\"EN-GB\">\u00a0<\/span><\/strong><strong><span lang=\"EN-GB\">4. DEPARTMENT OF THERIOGENOLOGY AND PRODUCTION POSTGRADUATE<\/span><\/strong><\/p>\r\n<p class=\"Default\"><strong><span lang=\"EN-GB\">CURRICULUM<\/span><\/strong><\/p>\r\n<p class=\"Default\"><span lang=\"EN-GB\">\u00a0<\/span><span style=\"font-size: 12.0pt; mso-bidi-font-family: Calibri; mso-bidi-theme-font: minor-latin; color: black;\"><span style=\"mso-list: Ignore;\">1.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><span style=\"font-size: 12.0pt; color: black;\">PGD Animal Health and Production<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l2 level1 lfo3;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; mso-bidi-font-family: Calibri; mso-bidi-theme-font: minor-latin; color: black;\"><span style=\"mso-list: Ignore;\">2.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; color: black;\">MSc Theriogenology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l2 level1 lfo3;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; mso-bidi-font-family: Calibri; mso-bidi-theme-font: minor-latin; color: black;\"><span style=\"mso-list: Ignore;\">3.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; color: black;\">MSc Animal Health and Production<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l2 level1 lfo3;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; mso-bidi-font-family: Calibri; mso-bidi-theme-font: minor-latin; color: black;\"><span style=\"mso-list: Ignore;\">4.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; color: black;\">PhD Theriogenology<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; text-indent: -18.0pt; line-height: normal; mso-list: l2 level1 lfo3;\"><!-- [if !supportLists]--><span style=\"font-size: 12.0pt; mso-bidi-font-family: Calibri; mso-bidi-theme-font: minor-latin; color: black;\"><span style=\"mso-list: Ignore;\">5.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span style=\"font-size: 12.0pt; color: black;\">PhD Animal Health and Production<\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-bottom: .0001pt; mso-add-space: auto; text-align: justify; line-height: normal;\"><strong><span lang=\"EN-GB\">5. DEPARTMENT OF VETERINARY MEDICINE<\/span><\/strong><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><strong><span lang=\"EN-GB\">Departmental Postgraduate Programmes <\/span><\/strong><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><span lang=\"EN-GB\" style=\"mso-bidi-font-weight: bold; mso-bidi-font-style: italic;\">1. MSc. <\/span><span lang=\"EN-GB\">Veterinary Medicine and <span style=\"mso-bidi-font-weight: bold; mso-bidi-font-style: italic;\">PhD. <\/span>Veterinary Medicine with options in: <\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><span lang=\"EN-GB\">i. Avian Medicine <\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><span lang=\"EN-GB\">ii. Large Animal Medicine <\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><span lang=\"EN-GB\">iii. Fish and Aquatic Medicine <\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><strong><span lang=\"EN-GB\">6. DEPARTMENT OF VETERINARY SURGERY AND RADIOLOGY<\/span><\/strong><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><strong><span lang=\"EN-GB\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0 <\/span>1. MSc. Veterinary Soft Tissue Surgery and PhD. Veterinary Soft Tissue Surgery <\/span><\/strong><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><strong><span lang=\"EN-GB\"><span style=\"mso-spacerun: yes;\">\u00a0<\/span>Options\/Research Areas <\/span><\/strong><\/p>\r\n<p class=\"Default\" style=\"margin-bottom: 1.35pt; text-align: justify;\"><span lang=\"EN-GB\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>General Surgery <\/span><\/p>\r\n<p class=\"Default\" style=\"margin-bottom: 1.35pt; text-align: justify;\"><span lang=\"EN-GB\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>Plastic and Reconstructive Surgery <\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><span lang=\"EN-GB\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>Wound Management<\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><span lang=\"EN-GB\">\u00a0<\/span><\/p>\r\n<p class=\"Default\" style=\"margin-left: 36.0pt; text-align: justify; text-indent: -18.0pt; mso-list: l3 level1 lfo4;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">1.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span lang=\"EN-GB\" style=\"mso-bidi-font-weight: bold;\">MSc. Veterinary Orthopaedic Surgery <\/span><\/p>\r\n<p class=\"Default\" style=\"margin-left: 36.0pt; text-align: justify; text-indent: -18.0pt; mso-list: l3 level1 lfo4;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">2.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span lang=\"EN-GB\">MSc. Veterinary Anaesthesia <\/span><\/p>\r\n<p class=\"Default\" style=\"margin-left: 36.0pt; text-align: justify; text-indent: -18.0pt; mso-list: l3 level1 lfo4;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">3.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span lang=\"EN-GB\" style=\"mso-bidi-font-weight: bold;\">MPhil<strong>\/<\/strong>PhD. Veterinary Orthopaedic Surgery<\/span><\/p>\r\n<p class=\"Default\" style=\"margin-left: 36.0pt; text-align: justify; text-indent: -18.0pt; mso-list: l3 level1 lfo4;\"><!-- [if !supportLists]--><span lang=\"EN-GB\" style=\"mso-fareast-font-family: 'Times New Roman';\"><span style=\"mso-list: Ignore;\">4.<span style=\"font: 7.0pt 'Times New Roman';\">\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/span><!--[endif]--><span lang=\"EN-GB\">MPhil\/PhD. PhD. Veterinary Anaesthesia<\/span><\/p>\r\n<p class=\"Default\" style=\"margin-left: 36.0pt; text-align: justify; tab-stops: right 468.0pt;\"><strong><span lang=\"EN-GB\">Options\/ResearchAreas <span style=\"mso-tab-count: 1;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/span><\/strong><\/p>\r\n<p class=\"Default\" style=\"text-align: justify; margin: 0cm 0cm 1.35pt 36.0pt;\"><span lang=\"EN-GB\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0 <\/span>Traumatology<\/span><\/p>\r\n<p class=\"Default\" style=\"margin-left: 36.0pt; text-align: justify;\"><span lang=\"EN-GB\"><span style=\"mso-spacerun: yes;\">\u00a0 <\/span>Fracture Management <\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpFirst\" style=\"text-align: justify; mso-layout-grid-align: none; text-autospace: none;\"><strong><span style=\"font-size: 12.0pt; line-height: 105%; font-family: 'Cambria',serif; mso-fareast-font-family: Calibri; mso-bidi-font-family: Cambria;\"><span style=\"mso-spacerun: yes;\">\u00a0 <\/span>Options\/Research Areas <\/span><\/strong><\/p>\r\n<p class=\"MsoListParagraphCxSpMiddle\" style=\"margin-bottom: 1.25pt; mso-add-space: auto; text-align: justify; mso-layout-grid-align: none; text-autospace: none;\"><span style=\"font-size: 12.0pt; line-height: 105%; mso-fareast-font-family: Calibri;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>Anaesthesia <\/span><\/p>\r\n<p class=\"MsoListParagraphCxSpLast\" style=\"margin-bottom: 1.25pt; mso-add-space: auto; text-align: justify; mso-layout-grid-align: none; text-autospace: none;\"><span style=\"font-size: 12.0pt; line-height: 105%; mso-fareast-font-family: Calibri;\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>Analgesia\/Pain Management <\/span><\/p>\r\n<p class=\"Default\" style=\"margin-left: 36.0pt; text-align: justify;\"><span lang=\"EN-GB\"><span style=\"mso-spacerun: yes;\">\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span>Wildlife Immobilization<\/span><\/p>\r\n<p class=\"Default\" style=\"text-align: justify;\"><span lang=\"EN-GB\">\u00a0<\/span><strong><span lang=\"EN-GB\">7. DEPARTMENT OF VETERINARY PHYSIOLOGY, BIOCHEMISTRY AND PHARMACOLOGY POSTGRADUATE PROGRAMME<\/span><\/strong><\/p>\r\n<p class=\"Default\"><strong><span lang=\"EN-GB\">1. <\/span><\/strong><span lang=\"EN-GB\">Masters of Science in Veterinary Physiology<\/span><\/p>\r\n<p class=\"Default\"><span lang=\"EN-GB\">2. Masters in Veterinary Pharmacology<\/span><\/p>\r\n<p class=\"Default\"><span lang=\"EN-GB\">3. Masters in Veterinary Toxicology<\/span><\/p>\r\n<p class=\"Default\"><span lang=\"EN-GB\">4. Masters in <span style=\"mso-bidi-font-weight: bold;\">Veterinary Pharmacology <\/span><\/span><\/p>\r\n<p class=\"Default\"><span lang=\"EN-GB\" style=\"mso-bidi-font-weight: bold;\">5. <\/span><span lang=\"EN-GB\">MPhil\/PhD. Philosophy in Veterinary Physiology<\/span><\/p>\r\n<p class=\"Default\"><span lang=\"EN-GB\">6. MPhil\/PhD <span style=\"mso-bidi-font-weight: bold;\">Veterinary Pharmacology <\/span><\/span><\/p>\r\n<p class=\"Default\"><span lang=\"EN-GB\" style=\"mso-bidi-font-weight: bold;\">7. MPhil\/PhD Veterinary Toxicology<\/span><\/p>\r\n<p class=\"Default\"><span lang=\"EN-GB\" style=\"mso-bidi-font-weight: bold;\">8. MPhil\/PhD <\/span><span lang=\"EN-GB\">Veterinary Physiology<\/span><\/p>"},{"icon":"","title":"CENTERS","content":"<p class=\"MsoNormal\"><strong><span style=\"font-size: 16.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">CENTRE FOR CONFLICT MANAGEMENT AND PEACE STUDIES<\/span><\/strong><strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><br \/> <\/span><\/strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">1. M.Sc. Conflict Management and Peace studies<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">2. Postgraduate Diploma in Conflict Management and Peace Studies<\/span><\/p>\r\n<p class=\"MsoNormal\"><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">3. MPhil\/PhD Conflict Management and Peace Studies<\/span><\/p>\r\n<p class=\"MsoNormal\"><strong><span style=\"font-size: 16.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\">6. CENTRE FOR GENDER AND WOMEN STUDIES<\/span><\/strong><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-font-kerning: 0pt; mso-ligatures: none;\"><br \/> 1. M.Phil\/Ph.D. Women Studies<br \/> 2. M.Phil\/Ph.D. Gender Studies<\/span><\/p>\r\n<p><span style=\"font-size: 12.0pt; line-height: 106%; font-family: 'Calibri Light',sans-serif; mso-fareast-font-family: 'Times New Roman'; mso-ansi-language: EN-US; mso-fareast-language: EN-US; mso-bidi-language: AR-SA;\">3. M.A. Women Studies<br \/> 4. M.Sc. Gender Studies<br \/> <!-- [if !supportLineBreakNewLine]--><br \/> <!--[endif]--><\/span><\/p>"},{"icon":"","title":"INSTITUTE OF EDUCATION","content":"<p class=\"SS1\">a. Postgraduate Diploma in Education (PGDE)<\/p>\r\n<p>\u00a0<\/p>\r\n<p class=\"SS1\"><span lang=\"EN-GB\">b.\u00a0 Postgraduate Diploma in Technology Education (PGDTE)<\/span><\/p>"}],"animate":"","el_class":""}}]},"2":{"attr":{"size":"4","type":"","bg_image":"","bg_color":"","bg_position":"center top","bg_repeat":"no-repeat","bg_attachment":"scroll","bg_size":"cover","class":"","class_inner":"","column_id":"","hidden_lg":"show","hidden_md":"show","hidden_sm":"show","hidden_xs":"show"},"items":[{"type":"gsc_button","size":12,"fields":{"title":"Click to Download ","size":"medium","color":"#ccc","border_color":"#CCC","background_color":"BLUE","border_radius":"radius-2x","link":"\/sites\/default\/files\/New%20Advert%20for%20ICT.pdf","color_hover":"","border_color_hover":"","background_color_hover":"","animate":"","el_class":""}}]},"3":{"attr":{"size":"3","type":"","bg_image":"","bg_color":"","bg_position":"center top","bg_repeat":"no-repeat","bg_attachment":"scroll","bg_size":"cover","class":"","class_inner":"","column_id":"","hidden_lg":"show","hidden_md":"show","hidden_sm":"show","hidden_xs":"show"},"items":[{"type":"gsc_icon_box","size":12,"fields":{"title":"Online Application Form","content":"","icon":" gv-icon-656","image":"","icon_position":"top-center","link":"https:\/\/portal.unijos.edu.ng","box_background":"","icon_background":"bg-theme","icon_color":"text-white","icon_width":"fa-2x","icon_radius":"radius-5x","icon_border":"border-1","skin_text":"text-dark","target":"off","animate":"","el_class":""}}]},"4":{"attr":{"size":"12","type":"","bg_image":"","bg_color":"","bg_position":"center top","bg_repeat":"no-repeat","bg_attachment":"scroll","bg_size":"cover","class":"","class_inner":"","column_id":"","hidden_lg":"show","hidden_md":"show","hidden_sm":"show","hidden_xs":"show"},"items":[{"type":"gsc_heading","size":12,"fields":{"title":"Postgraduate Programs","sub_title":"","desc":"","icon":"","align":"align-center","style":"style-default","style_text":"text-dark","remove_padding":"","el_class":"","animate":""}},{"type":"gsc_drupal_block","size":12,"fields":{"title":"Find a course","block_drupal":"gavias_edubiz_exposedformcoursecourse_filter","hidden_title":"on","align_title":"title-align-left","remove_margin":"on","style_text":"text-dark","el_class":"","animate":""}}]}}},{"attr":{"bg_image":"","bg_color":"#f5f5f5","bg_position":"center top","bg_repeat":"no-repeat","bg_attachment":"scroll","bg_size":"cover","bg_video":"","bg_video_mp4":"","bg_video_webm":"","bg_video_ogv":"","style_space":"default","padding_top":"0","padding_bottom":"0","margin_top":"0","margin_bottom":"0","layout":"container","equal_height":"","icon":"","class":"","row_id":""},"columns":{"1":{"attr":{"size":"12","type":"","bg_image":"","bg_color":"","bg_position":"center top","bg_repeat":"no-repeat","bg_attachment":"scroll","bg_size":"cover","class":"","class_inner":"","column_id":"","hidden_lg":"show","hidden_md":"show","hidden_sm":"show","hidden_xs":"show"},"items":[{"type":"gsc_heading","size":12,"fields":{"title":"Programs","sub_title":"","desc":"","icon":"","align":"align-center","style":"style-default","style_text":"text-dark","remove_padding":"","el_class":"","animate":""}},{"type":"gsc_view","size":12,"fields":{"title_admin":"Duplicate of Course for CENTERS || PG-Tab #2-3","title":"","view":"duplicate_of_course_for_centers-----block_9","view_arg":"","show_title":"hidden","style_text":"text-dark","align_title":"title-align-left","remove_margin":"off","el_class":"","animate":""}}]}}},{"attr":{"bg_image":"","bg_color":"","bg_position":"center top","bg_repeat":"no-repeat","bg_attachment":"scroll","bg_size":"cover","bg_video":"","bg_video_mp4":"","bg_video_webm":"","bg_video_ogv":"","style_space":"default","padding_top":"0","padding_bottom":"0","margin_top":"0","margin_bottom":"0","layout":"container","equal_height":"","icon":"","class":"","row_id":""},"columns":{"1":{"attr":{"size":"12","type":"","bg_image":"","bg_color":"","bg_position":"center top","bg_repeat":"no-repeat","bg_attachment":"scroll","bg_size":"cover","class":"","class_inner":"","column_id":"","hidden_lg":"show","hidden_md":"show","hidden_sm":"show","hidden_xs":"show"},"items":[{"type":"gsc_heading","size":12,"fields":{"title":"Postgraduate Staff","sub_title":"","desc":"","icon":"","align":"align-center","style":"style-default","style_text":"text-dark","remove_padding":"","el_class":"","animate":""}}]},"2":{"attr":{"size":"12","type":"","bg_image":"","bg_color":"","bg_position":"center top","bg_repeat":"no-repeat","bg_attachment":"scroll","bg_size":"cover","class":"","class_inner":"","column_id":"","hidden_lg":"show","hidden_md":"show","hidden_sm":"show","hidden_xs":"show"},"items":[{"type":"gsc_view_tabs_ajax","size":12,"fields":{"title":"","style":"style-1","animate":"","el_class":"","title_1":"All Staff","view_1":"team-----block_4","title_2":"","view_2":"","title_3":"","view_3":"","title_4":"","view_4":"","title_5":"","view_5":"","title_6":"","view_6":"","title_7":"","view_7":"","title_8":"","view_8":"","title_9":"","view_9":"","title_10":"","view_10":""}}]}}}]') (Line: 48)
Drupal\gavias_blockbuilder\Plugin\Field\FieldFormatter\BlockBuilderFormatter->viewElements(Object, 'en') (Line: 89)
Drupal\Core\Field\FormatterBase->view(Object, 'en') (Line: 265)
Drupal\Core\Entity\Entity\EntityViewDisplay->buildMultiple(Array) (Line: 340)
Drupal\Core\Entity\EntityViewBuilder->buildComponents(Array, Array, Array, 'full') (Line: 24)
Drupal\node\NodeViewBuilder->buildComponents(Array, Array, Array, 'full') (Line: 282)
Drupal\Core\Entity\EntityViewBuilder->buildMultiple(Array) (Line: 239)
Drupal\Core\Entity\EntityViewBuilder->build(Array)
call_user_func_array(Array, Array) (Line: 101)
Drupal\Core\Render\Renderer->doTrustedCallback(Array, Array, 'Render #pre_render callbacks must be methods of a class that implements \Drupal\Core\Security\TrustedCallbackInterface or be an anonymous function. The callback was %s. See https://www.drupal.org/node/2966725', 'exception', 'Drupal\Core\Render\Element\RenderCallbackInterface') (Line: 788)
Drupal\Core\Render\Renderer->doCallback('#pre_render', Array, Array) (Line: 374)
Drupal\Core\Render\Renderer->doRender(Array, ) (Line: 204)
Drupal\Core\Render\Renderer->render(Array, ) (Line: 242)
Drupal\Core\Render\MainContent\HtmlRenderer->Drupal\Core\Render\MainContent\{closure}() (Line: 580)
Drupal\Core\Render\Renderer->executeInRenderContext(Object, Object) (Line: 243)
Drupal\Core\Render\MainContent\HtmlRenderer->prepare(Array, Object, Object) (Line: 132)
Drupal\Core\Render\MainContent\HtmlRenderer->renderResponse(Array, Object, Object) (Line: 90)
Drupal\Core\EventSubscriber\MainContentViewSubscriber->onViewRenderArray(Object, 'kernel.view', Object)
call_user_func(Array, Object, 'kernel.view', Object) (Line: 142)
Drupal\Component\EventDispatcher\ContainerAwareEventDispatcher->dispatch(Object, 'kernel.view') (Line: 174)
Symfony\Component\HttpKernel\HttpKernel->handleRaw(Object, 1) (Line: 81)
Symfony\Component\HttpKernel\HttpKernel->handle(Object, 1, 1) (Line: 58)
Drupal\Core\StackMiddleware\Session->handle(Object, 1, 1) (Line: 48)
Drupal\Core\StackMiddleware\KernelPreHandle->handle(Object, 1, 1) (Line: 191)
Drupal\page_cache\StackMiddleware\PageCache->fetch(Object, 1, 1) (Line: 128)
Drupal\page_cache\StackMiddleware\PageCache->lookup(Object, 1, 1) (Line: 82)
Drupal\page_cache\StackMiddleware\PageCache->handle(Object, 1, 1) (Line: 48)
Drupal\Core\StackMiddleware\ReverseProxyMiddleware->handle(Object, 1, 1) (Line: 51)
Drupal\Core\StackMiddleware\NegotiationMiddleware->handle(Object, 1, 1) (Line: 23)
Stack\StackedHttpKernel->handle(Object, 1, 1) (Line: 707)
Drupal\Core\DrupalKernel->handle(Object) (Line: 19)
Academic
School of Postgraduate Studies
Postgraduate School Admission 2024
Prof. Dakul Anthony
Dean
General Admission Requirement:
1. A candidate seeking admission must possess five credit passes including English and Mathematics and other relevant subjects at O' Level. Candidates seeking Admission into a Master’s Degree or Postgraduate Diploma of the University of Jos must hold a good (First or second class) Honours Degree of this University or of other Universities recognized by the Senate of University of Jos. The first degree must be in a discipline relevant to the programme into which admission is being sought.
2. A candidate seeking admission into an M.Phil/Ph.D. programme must in addition possess a Master’s degree in the relevant discipline. M.Phil/Ph.D. candidates are in addition required to have returned a weighted Score Average (WSA) of 60% and above in the final assessment result for the Master’s Degree as well as 60% and above in the Research Project. On admission, M.Phil/Ph.D candidates register for M.Phil in the first instance and on satisfactory performance may be subsequently upgraded to Ph.D. registration.
3. For all admissions, degree result transcripts are required.
4. All Advertised programmes will run on a full-time basis.
FACULTY OF ARTS
A. DEPARTMENT OF ENGLISH
1.
MA English Language
2.
MA Literature in English
3.
MA Oral Literature
4.
MPhil/PhD English Language
5.
MPhil/PhD Literature in English
6.
MPhil/PhD Oral Literature
B. DEPARTMENT OF HISTORY AND INTERNATIONAL STUDIES
i.
M.A. Economic History
ii.
M.A. African History
iii.
M.A. History and International Studies
iv.
M.Phil/Ph.D Economic History
v.
M.Phil/Ph.D African History
vi.
M.Phil/Ph.D History and International Studies
C. DEPARTMENT OF LINGUISTICS AND NIGERIAN LANGUAGES
Programmes:
M Phil/Ph.D in Linguistics
M. A Linguistics
D. DEPARTMENT OF MASS COMMUNICATION
i.
Postgraduate Diploma in Mass Communication
ii.
M.A Mass Communication
iii.
MPhil/Ph.D Mass Communication
E. DEPARTMENT OF RELIGION AND PHILOSOPHY
a. M.A Arabic
b. M.A. Ethics and Philosophy
c. M.A New Testament
d. M.A Sociology of Religions
e. M.A Church History
f. M.A Interaction of Religions
g.
M.A Old Testament
h.
M.A Islamic Studies
i. M.A African Traditional Religion
MPHIL/PHD PROGRAMMES
a. MPhil/PhD. Arabic
b. MPhil/PhD. Ethics and Philosophy
c. MPhil/PhD. New Testament
d. MPhil/PhD. Sociology of Religions
e. MPhil/PhD. Church History
f
MPhil/PhD. Interaction of Religions
g. MPhil/PhD.
Old Testament
h.
MPhil/PhD. Islamic Studies
i.
MPhil/PhD. African Traditional Religion
F. Department of Theatre and Film Arts
a.
M.A Play creating
b. M.A Directing
c. M.A Dramatic Literature & Criticism
d. M.A Film Arts
e. M.A. Development Theatre/Communication Studies
g. MPhil/PhD. Theatre and Film Arts
G. DEPARTMENT OF ARCHAEOLOGY AND HERITAGE STUDIES
a.
M.A. Degree in Archaeology
b. MPhil Degree in Archaeology
FACULTY OF AGRICULTURE
Department of Animal Production
1.
Postgraduate Diploma (PGD) Animal Production
2.
M.Sc. in
Animal Science
3.
MPhil/PhD. Animal Science
(b)
M.Sc. in
Animal Science (Options in
Animal Breeding and Genetics, Monogastric Nutrition, Ruminant Nutrition, Animal Management/Production, Pasture and Rangeland Management/Production, Animal Products and Processing, Animal Physiology and Reproduction)
(c)
MPhil/PhD. Animal Science (with options in Animal Breeding and Genetics, Monogastric Nutrition, Ruminant Nutrition, Animal Management/Production, Pasture and Rangeland Management/Production, Animal Products and Processing, Animal Physiology and Reproduction)
Areas of Specialization at PG level
1
Animal Breeding and Genetics
2
Monogastric Animal Nutrition
3
Ruminant Animal Nutrition
4
Animal Management/Production
5
Pasture and Rangeland Management/Production
6
Animal Products and Processing
Animal Physiology and Reproduction
FACULTY OF BASIC CLINICAL SCIENCES
A. DEPARTMENT OF CHEMICAL PATHOLOGY
I.
MSc in Clinical Pathology/ Clinical Biochemistry
B. DEPARTMENT OF MEDICAL MICROBIOLOGY
I.
MSc. Medical Microbiology
II.
PhD Medical Microbiology
Available Areas of Research in Medical Microbiology
A candidate may undertake research in any of the major specialties below:
1.
Bacteriology
2.
Immunology
3.
Medical Mycology
4.
Parasitology
5.
Virology.
FACULTY OF BASIC MEDICAL SCIENCES
A. DEPARTMENT OF BIOCHEMISTRY
i.
Postgraduate Diploma in Nutrition and Dietetics.
ii.
M.Sc. Biochemistry
iii.
M.Phil/Ph.D. Biochemistry
Areas of Specialization
i.
Medical Biochemistry(cancer and diabetes)
ii.
Molecular Biology and Biotechnology
iii.
Parasite Biochemistry
iv.
Environmental Biochemistry
v.
Nutrition and Nutrigenomics
vi.
Toxicology
vii.
Phytomedicine/Ethnobiochemistry
viii.
Micro biome
ix.
Forensic Biochemistry
x.
Drug Research
B. DEPARTMENT OF HUMAN ANATOMY
i.
M.Sc. Human Anatomy
ii. M.Phil/Ph.D Human Anatomy
C. DEPARTMENT OF HUMAN PHYSIOLOGY
i. M.Sc. Physiology
ii. M.Phil/Ph.D. Physiology
FACULTY OF CLINICAL SCIENCES
A. DEPARTMENT OF OBSTETRICS AND GYNAECOLOGY
1. Master of Reproductive Sciences
2. MPhil/Ph.D Reproductive Sciences
3. MD Reproductive Sciences/OBGYN
4. Doctor of Medicine (MD) Degree Programme in Obstetrics and Gynaecology
B
.
DEPARTMENT OF COMMUNITY MEDICINE
i.
M.Sc. Clinical Epidemiology
ii. M.Sc. Field Epidemiology
iii. Masters of Public Health
FACULTY OF EDUCATION
A
.
DEPARTMENT OF ADULT EDUCATION
1.
MPhil/Ph.D. Adult Education
2.
Master of Education (Adult Education)
3. Postgraduate Diploma (PGD) in Adult Education and Community Development
Available specializations
1.
Adult and Non-Formal Education
2.
Community Development
3.
Social Welfare
4.
Industrial Education
5.
Communication Arts in Adult Education/Community Development
6.
Vocational Adult Education
7.
Cooperative Management
8.
Distance Education
9.
Extension Education
B. DEPARTMENT OF SPECIAL EDUCATION AND REHABILITATION SCIENCES
1. M.Phil/Ph.D Hearing Handicap
2. M.Phil/Ph.D Learning Disabilities
3. M.Phil/Ph.D Visual Handicaps
4. M.Ed. Hearing Handicap
5. M.Ed. Learning Disabilities
6. M.Ed. Visual Handicaps.
C. DEPARTMENT OF ARTS EDUCATION
1. M.Phil/Ph.D. History and International Studies Education
2. M.Phil/Ph.D. Religion Education
3. MPhil/Ph.D. English Education
4. MPhil/Ph.D. French Education
5. M.Ed. English Education
6. M.A. Ed. History and International Studies Education
7.
M.Ed. French Education
8. M.Ed. Religion Education
D. DEPARTMENT OF EDUCATIONAL FOUNDATION
1. M.Phil/Ph.D. Guidance and Counseling
2. M.Phil/Ph.D. Philosophy of Education
3. M.Phil/Ph.D. Sociology of Education
4. M.Phil/Ph.D. Educational Psychology
5. M.Phil/Ph.D. Educational Research, Measurement and Evaluation
6. M.Phil/Ph.D. Educational Management
7. M.Ed. Guidance and Counseling
8. M.Ed. Philosophy of Education
9. M.Ed. Sociology of Education
10. M.Ed. Educational Psychology
11. M.Ed. Educational Research, Measurement and Evaluation
12. M.Ed. Educational Management
E. DEPARTMENT OF SOCIAL SCIENCE EDUCATION
1. M.Phil/Ph.D. Social Studies Education
2. MPhil/PhD. Library and Information Science
3. M.Ed. Social Studies Education
4. M.Sc. Ed. Economics Education
5. Master in Library and Information Science (MLIS)
6.
Postgraduate Diploma in Library and Information Science (PGDLIS)
F. DEPARTMENT OF PHYSICAL AND HEALTH
EDUCATION.
1. MPhil/Ph.D. Physical Education
2. MPhil/Ph.D. Health Education
3. M.Sc. Ed Physical Education
4.
M.Sc. Ed. Health Education
Areas of specialisation
a.
Sports Management
b.
Exercise and Sports Science
c.
Physical Education Curriculum
d.
Health Education Curriculum
e.
Public Health Education & Community Health Education
f.
School health Education
g.
Environmental Health Education
G. DEPARTMENT OF SCIENCE AND TECHNOLOGY EDUCATION
1. M.Phil./Ph.D. Biology Education
2. M.Phil./Ph.D. Chemistry Education
3. M.Phil./Ph.D. Physics Education
4. M.Phil./Ph.D. Educational Technology
5. M.Phil./Ph.D. Mathematics Education
6. M.Phil./Ph.D. Science Education
7. M.Phil./Ph.D. Curriculum Studies
8. M.Phil./Ph.D. Geography Education
9. MPhil/PhD.
Home Economics
10. MPhil/Ph.D. Computer Science Education
11. MPhil/Ph.D. Technology Education
Areas of specialization:
Building Technology
Electrical/Electronic Technology
Mechanical Technology
12. M.Sc. Ed. Biology Education
13. M.Sc. Ed. Chemistry Education
14. M.Sc. Ed. Physics Education
15. M.Sc. Ed. Educational Technology
16. M.Sc. Ed. Mathematics Education
17. M.Sc. Ed. Geography Education
18. M.Sc. Ed. Science Education
19. M.Sc. Ed. Curriculum Studies
20. M.Sc. Ed Technology Education
21. M.Sc. Ed. Computer Science Education
22. M.Sc. Ed. Home Economics
23.
Postgraduate Diploma in Computer Science Education (PGDCSE)
Areas of specialisation:
Building Technology
Electrical/Electronic Technology
Mechanical Technology
Home Economics Education
Child development
Home Management
Clothing Textile
Food nutrition and Meal Management
Hospitality and institutional Management
Building/Woodwork Technology
Electrical/Electronic Technology
Metal Work/Automobile Technology
FACULTY OF ENGINEERING
A.
DEPARTMENT OF CIVIL ENGINEERING
1.
PGD Civil Engineering
2.
M.Sc. Geotechnical Engineering
3.
M.Sc. Structural Engineering
4.
M.Sc. Water Resources and Environmental Engineering
5.
M.Phil./PhD Geotechnical Engineering
6.
M.Phil./PhD Structural Engineering
7.
M.Phil./PhD Water Resources and Environmental Engineering
8.
M.Phil./PhD Civil Engineering
B.
DEPARTMENT OF ELECTRICAL / ELECTRONICS ENGINEERING
1. PGD
Power and Machines
2. PGD
Computer Engineering
3. PGD
Electronics and Telecommunication
4. M.Sc. Power and Machines
5. M.Sc. Computer Engineering
6. M.Sc. Electronics and Telecommunication
7
. M.Phil./PhD Power and Machines
8. M.Phil./PhD Computer Engineering
1.
M.Phil./PhD Electronics and Telecommunication
2.
M.Phil)/ Ph.D.  Electrical/Electronic/Computer Engineering
C.
DEPARTMENT OF MECHANICAL ENGINEERING
1. PGD Mechanical Engineering
2.
M.Sc. Mechanical Engineering
3. M.Sc. Energy Engineering
4. M.Sc. Industrial and Production Engineering
5. M.Phil./PhD Energy Engineering
6. M.Phil./PhD Industrial and Production Engineering
7. MPhil/PhD.
Mechanical Engineering
D.
DEPARTMENT OF MINING ENGINEERING
1. Postgraduate Diploma in Mining Engineering
2. M.Sc. Mining Engineering
3.
M.Phil/PhD Mining Engineering
Areas of specialization are:
(I)
Surface Mining Engineering
(II)
Underground Mining Engineering
(III)
Rock Mechanics Engineering
FACULTY OF ENVIRONMENTAL SCIENCES
DEPARTMENT OF ARCHITECTURE
1. Masters of Science (M.Sc.) Architecture by research
2. Masters of Science (M.Sc.) Architecture by design
3. Doctor of Philosophy (PhD.) Architecture by research
4. Doctor of Architecture (PhD.) by design
2. Department of Building
a. M.Phil/Ph.D. in Construction Management
b. M.Phil/Ph.D. Construction Technology
c. M.Sc. Construction Management
d. M.Sc. Construction Technology
3. DEPARTMENT OF ESTATE MANAGEMENT
1. Postgraduate Diploma in Estate Management
2. M. Sc. Property Development and Management
3. M.Sc. Housing Studies
4. M.Sc. Property Valuation and Approval
5. M.Sc. Land Management
6. M. Phil/PhD Valuation and Appraisal
7. M. Phil/PhD Property Development and Management
4.
DEPARTMENT OF GEOGRAPHY AND PLANNING
1. M.Phil/Ph.D Environmental and Resources Planning (ERP)
2. M.Phil/Ph.D Population and Man Power Planning (PMP)
3. MPhil/Ph.d Geography (with options
in Climatology)
4. MPhil/Ph.d Geography (with options
in Geomorphology)
5. MPhil/Ph.d Geography (with options
in Transportation)
6. MPhil/Ph.d Geography (with options
in Population)
7. M.Sc. Environmental and Resources Planning (ERP)
8. M.Sc. Population and Man Power Planning (PMP)
9. M.Sc. Geography (with options
in Climatology)
10. M.Sc. Geography (with options
in Geomorphology)
11. M.Sc. Geography (with options
in Transportation)
12. M.Sc. Geography (with options
in Population)
13. PGD Tourism and Recreation Management
14. PGD Geographic Information Systems (GIS)
15. PGD Environmental Resources Management
5.
DEPARTMENT OF QUANTITY SURVEYING
1. Postgraduate Programmes in Quantity Surveying
2. Master of Science Degree in Quantity Surveying
6. DEPARTMENT OF URBAN AND REGIONAL PLANNING
1. M.Phil/Ph.D. Urban and Regional Planning
2. M.Sc. Urban and Regional Planning
3. Postgraduate Diploma Urban and Regional Planning
FACULTY OF HEALTH SCIENCES AND TECHNOLOGY
A.
Department Of Medical Laboratory Science
1.
Postgraduate Diploma MLS (Histopathology)
2.
Postgraduate Diploma MLS (Chemical Pathology)
3.
MSc. MLS Medical Microbiology (Medical Parasitology, Medical Bacteriology, Medical Virology &    Medical Mycology)
4. MSc MLS Haematology & blood transfusion science
5. MSc. MLS Chemical pathology
6. MSc. MLS Histopathology
7. MSc. MLS Immunology and immunochemistry
8.
MPhil/PhD. MLS Medical Microbiology (Medical Parasitology, Medical Bacteriology, Medical Virology &  Medical Mycology)
9.
MPhil/PhD MLS Haematology & blood transfusion science
1.
MPhil/PhD MLS Chemical pathology
2.
MPhil/PhD MLS Histopathology
3.
MPhil/PhD MLS Immunology and immunochemistry
2. DEPARTMENT OF NURSING
1. MSc Medical and Surgical Nursing
2. MSc Psychiatric/Mental Health Nursing
3. MSc Community Health Nursing
4. MSc Maternal and Child Health Nursing
5. MSc Nursing Education
6. MSc Health and Nursing Administration
7. M.Phil/PhD Medical and Surgical Nursing
8. M.Phil/PhD Psychiatric/Mental Health Nursing
9. M.Phil/PhD Community Health Nursing
10. M.Phil/PhD Maternal and Child Health Nursing
11. M.Phil/PhD Nursing Education
12. M.Phil/PhD Health and Nursing Administration
FACULTY OF LAW
1. LL.M. (Taxation Law and Policy)
2. LL.M. (Energy and Natural Resources Law)
3. LL.M. (Intellectual Property Law and Policy)
4. LL.M. (International Law and Diplomacy)
5. LL.M. (Law of Alternative Dispute Resolution)
6. LL.M. (Constitutional and Human Rights Law)
7. LL.M. (Law)
8. MPhil/PhD. Law
9. MPhil/PhD Law and Diplomacy
FACULTY OF MANAGEMENT SCIENCES
A. DEPARTMENT OF ACCOUNTING AND FINANCE
1. M.Sc. Accounting and Finance
2. M.Sc. Forensic Accounting
3. MPhil/PhD Accounting
B. DEPARTMENT OF ACTUARIAL SCIENCE
1. Postgraduate Diploma in Actuarial Science
2. Masters of Science (M.Sc.) in Actuarial Science
c. Department of Business Administration
1.
M.Phil./Ph.D. Management
2. M.Sc. Management
3. Postgraduate Diploma in Management (PGDM)
D. DEPARTMENT OF BANKING AND FINANCE
1.
PGD Banking and Finance
2.
M.Sc. Banking and Finance
3.
MPhil./Ph.D. Banking and Finance
E. DEPARTMENT OF MARKETING
1. PGD Marketing
2. MSc. Marketing
3. MPhil/PhD Marketing
F. DEPARTMENT OF INSURANCE
1. PGD Insurance
2. MSc. Insurance & Risk Management
3. MPhil/PhD Insurance & Risk Management
FACULTY OF NATURAL SCIENCES
A. DEPARTMENT OF COMPUTER SCIENCE
1. Postgraduate Diploma in Computer Science
2. M.Sc. Computer Science Programme
3. MPhil/ Ph.D. Computer Science
B. DEPARTMENT OF GEOLOGY
1. M.Phil/Ph.D. Ore Geology
2. M.Phil/Ph.D. Geochemistry
3. M.Phil/Ph.D. Environmental Geology
4. M.Phil/Ph.D. Hydrogeology and Engineering Geology
5. M.Sc. Mineral Exploration and Mining Geology
6. M.Sc. Engineering Geology and Hydrogeology
7. M.Sc. Petroleum and Geology/Sedimentology
8. M.Sc. Environmental Geology
9. Postgraduate Diploma in Environmental Geology (PDEG)
10. Postgraduate Diploma in Mining Geology (PDMG)
C. Department of Science Laboratory Technology
1
.
M.Sc. Biological Sciences Techniques
2. M.Sc. Biochemistry Techniques
3.  M.Sc. Chemical Sciences /Petroleum Techniques
4. M.Sc. Geology Techniques
5. M.Sc. Microbiology Techniques
1.
M.Phil/Ph.D Degree in Science Laboratory Technology (Biological Sciences Techniques)
2.
M.Phil/Ph.D Degree in Science Laboratory Technology (Biochemistry Techniques)
3.
M.Phil/Ph.D Degree in Science Laboratory Technology (Microbiology Techniques)
4.
M.Phil/Ph.D Degree in Science Laboratory Technology (Chemical Sciences /Petroleum Techniques)
5.
M.Phil/Ph.D Degree in Science Laboratory Technology (Geology Techniques)
D. Department of Physics
1.  M.Phil/Ph.D. Acoustics
2.  M.Phil/Ph.D. Atmospheric Physics
3.  M.Phil/Ph.D. Electronic and Telecommunication
4. M.Phil/Ph.D. Geophysics
5.  M.Phil/Ph.D. Medical/Radiation Biophysics
6. M.Phil/Ph.D. Theoretical Physics
7. M.Sc. Pure Physics
8. M.Sc. Applied Physics
9. Postgraduate Diploma in Electronics and Physics
E. Department of Chemistry
1. M.Phil/Ph.D. Applied Analytical Chemistry
2. M.Phil/Ph.D. Applied Inorganic Chemistry
3. M.Phil/Ph.D. Applied Organic Chemistry
4. M.Phil/Ph.D. Applied Physical Chemistry
5. M.Sc. Applied Analytical Chemistry
6. M.Sc. Applied Inorganic Chemistry
7. M.Sc. Applied Organic Chemistry
8. M.Sc. Applied Physical Chemistry
9. Postgraduate Diploma in Environmental and Industrial Chemistry
F. Department of Plant Science and Technology
1. M.Phil/Ph.D Phycology and Aquatic Plants
2. M.Phil/Ph.D Plant Physiology
3. M.Phil/Ph.D Plant Anatomy
4. M.Phil/Ph.D Plant Ecology
5. M.Phil/Ph.D Plant Pathology
6. M.Phil/Ph.D Plant Taxonomy
7. M.Phil/Ph.D Medicinal Botany
8. M.Phil/Ph.D  Cytogenetic and Plant Breeding
9. M.Phil/Ph.D Applied Microbiology
10. MPhil/PhD. Plant Biotechnology
11. M.Sc. Phycology and Aquatic Plants
12. M.Sc. Plant Physiology
13. M.Sc. Plant Anatomy
14. M.Sc. Plant Ecology
15. M.Sc. Plant Pathology
16. M.Sc. Taxonomy and Systematics
17. M.Sc. Medicinal Botany
18. M.Sc. cytogenic and Plant Breeding
19. M.Sc. Applied Microbiology and Plant Pathology
20. M.Sc. Plant Biotechnology
21. Postgraduate Diploma (PGD) Plant Biotechnology
G. Department of Zoology
1. M.Phil/Ph.D. Entomology (with specialization in Entomology (Medical, Agricultural and General),
2. M.Phil/Ph.D. Parasitology(Medical, Veterinary and General)
3. M.Phil/Ph.D. Applied Hydrobiology and Fisheries
4. M.Sc. Applied Entomology and Parasitology
5. M.Sc. Applied Hydrobiology and Fisheries
6. M.Sc. Conservation Biology
H. Department of Microbiology
1. M.Phil/Ph.D Microbial Biotechnology
2. M.Phil/Ph.D Food and Industrial Microbiology
3. M.Phil/Ph.D Environmental Microbiology
4. M.Phil/Ph.D Public Health and Sanitary Microbiology
5. M.Phil/Ph.D Medical Microbiology and Immunology
6. M.Sc. Microbial Biotechnology
7. M.Sc. Food and Industrial Microbiology
8. M.Sc. Environmental Microbiology
9. M.Sc. Public Health and Sanitary Microbiology
10. M.Sc. Medical Microbiology and Immunology
11. Postgraduate Diploma in Microbiology
I. Department of Mathematics
M.Phil/Ph.D Programmes
:
1. M.Phil/Ph.D. Abstract Algebra
2. M.Phil/Ph.D. Numerical Analysis
3. M.Phil/Ph.D. Biomathematics
4. M.Phil/Ph.D. Control Theory
5. M.Sc. Abstract Algebra
6. M.Sc. Numerical Analysis
7. M.Sc. Biomathematics
8. M.Sc. Control Theory
FACULTY OF SOCIAL SCIENCES
1. DEPARTMENT OF ECONOMICS
1. M.Phil/Ph.D Economics
2. M.Sc. Economics
2. DEPARTMENT OF GENERAL AND APPLIED PSYCHOLOGY
1. M.Phil/Ph.D. Clinical Psychology
2. M.Phil/Ph.D. Organizational Psychology
3.
M.Sc. Clinical Psychology
4. M.Sc. Organizational Psychology
5.
M.Sc. Social and Terrorism Psychology
6. M.Sc. Counselling Psychology
7. Postgraduate Diploma in Psychology
3. DEPARTMENT OF POLITICAL SCIENCE
1. M.Phil/Ph.D. International Relations
2. M.Phil/Ph.D. Political Economy and Development Studies
3. M.Phil/Ph.D. Public Administration.
4. M.Sc. International Relations and Strategic Studies
5. M.Sc. Political Economy and Development Studies
6. M.Sc. Public Policy and Administration.
7. Master of Research and Public Policy (MRPP)
4. Department of Sociology
1.
Postgraduate Diploma (PGD) in Social Work
2.
M.Sc. Sociology
(with Specialization in Criminology, Medical Sociology, Sociology of Development,
Industrial Sociology, etc.)
3.
M.Sc. Social Work (MSSW)
4. MPhil/PhD Sociology
5. MPhil/PhD Social Work
.
FACULTY OF PHARMACEUTICAL SCIENCES
1.
DEPARTMENT OF PHARMACEUTICAL AND MEDICINAL CHEMISTRY
1. Post Graduate Diploma in Pharmaceutical Chemistry
2. M.Sc. Pharmaceutical Chemistry
3. M.Sc. Bioinformatics and Genomics
4. M.Phil/Ph.D Pharmaceutical Chemistry
2. DEPARTMENT OF PHARMACEUTICAL TECHNOLOGY AND INDUSTRIAL PHARMACY
1. M.Sc. Pharmaceutical Technology
2. M.Phil/Ph.D Pharmaceutical Technology
3. DEPARTMENT OF PHARMACOGNOSY AND TRADITIONAL MEDICINE
1. M.Sc. Pharmacognosy and Traditional Medicine
2. M.Phil/Ph.D Pharmacognosy and Traditional Medicine
1.
DEPARTMENT OF PHARMACEUTICAL MICROBIOLOGY AND BIOTECHNOLOGY
1. M.Sc. Pharmaceutical Microbiology
2. M.Sc. Biotechnology
3. M.Phil/Ph.D Pharmaceutical Microbiology
4. M.Phil/PhD Biotechnology
2.
DEPARTMENT OF PHARMACEUTICS
1. M.Sc. Drug Delivery
2. M.Sc. Cosmetic Science
3. M.Phil/Ph.D Drug Delivery
4. M.Phil/Ph.D Cosmetic Science
3.
DEPARTMENT OF PHARMACOLOGY AND TOXICOLOGY
1.
M.Sc. Pharmacology
2.
M.Sc. Clinical Pharmacology
3.
M.Sc. Forensic Toxicology
4.
MPhil/Ph.D Pharmacology
5.
MPhil/Ph.D Clinical Pharmacology
6.
MPhil/Ph.D Forensic Toxicology
4.
DEPARTMENT OF CLINICAL PHARMACY AND PHARMACY PRACTICE
1. Post Graduate Diploma (PGD) in Clinical Pharmacy and Pharmacy Practice
2. M.Sc. Clinical Pharmacy and Pharmacy
3. M.Phil/Ph.D Clinical Pharmacy and Pharmacy Practice
FACULTY OF VETERINARY MEDICINE
DEPARTMENT OF VETERINARY ANATOMY POSTGRADUATE PROGRAMMES
1. Master of Science (MSc) in Veterinary Anatomy
2. Doctor of Philosophy (PhD) in Veterinary Anatomy
2. DEPARTMENT OF VETERINARY MICROBIOLOGY AND PATHOLOGY
MICROBIOLOGY PG PROGRAMME
1.
MSc/PhD in Veterinary Anatomic and Clinical Pathology
2.
PhD in: Bacteriology and Molecular biology
3.
MSc/PhD in Veterinary Immunology
4.
PhD in: Veterinary Mycology
5.
MSc/PhD in: Veterinary Virology
6.
MSc/PhD in: Veterinary Microbiology
3. DEPARTMENT OF VETERINARY
PARASITOLOGY AND ENTOMOLOGY
POSTGRADUATE CURRICULUM
1.
Veterinary Protozoology
(MSc. Vet. Protozoology),
2. Veterinary Helminthology
(MSc. Vet. Helminthology)
and
3. Veterinary Entomology
(MSc. Vet .Entomology)
.
4. Veterinary Protozoology
(PhD Veterinary Protozoology),
5. Veterinary Helminthology
(PhD Veterinary Helminthology)
and
6. Veterinary Entomology
(PhD Veterinary Entomology)
.
7.
Postgraduate Diploma In Veterinary Parasitology (PGDVP
)
3.
DEPARTMENT OF VETERINARY PUBLIC HEALTH AND PREVENTIVE MEDICINE POSTGRADUATE CURRICULUM
1.
M.Sc.
Veterinary Public Health and Preventive Medicine
2.
M.Sc. One Health
3.
MPhil/Ph.D
Veterinary Public Health and Preventive Medicine
4. DEPARTMENT OF THERIOGENOLOGY AND PRODUCTION POSTGRADUATE
CURRICULUM
1.
PGD Animal Health and Production
2.
MSc Theriogenology
3.
MSc Animal Health and Production
4.
PhD Theriogenology
5.
PhD Animal Health and Production
5. DEPARTMENT OF VETERINARY MEDICINE
Departmental Postgraduate Programmes
1. MSc.
Veterinary Medicine and
PhD.
Veterinary Medicine with options in:
i. Avian Medicine
ii. Large Animal Medicine
iii. Fish and Aquatic Medicine
6. DEPARTMENT OF VETERINARY SURGERY AND RADIOLOGY
1. MSc. Veterinary Soft Tissue Surgery and PhD. Veterinary Soft Tissue Surgery
Options/Research Areas
General Surgery
Plastic and Reconstructive Surgery
Wound Management
1.
MSc. Veterinary Orthopaedic Surgery
2.
MSc. Veterinary Anaesthesia
3.
MPhil
/
PhD. Veterinary Orthopaedic Surgery
4.
MPhil/PhD. PhD. Veterinary Anaesthesia
Options/ResearchAreas
Traumatology
Fracture Management
Options/Research Areas
Anaesthesia
Analgesia/Pain Management
Wildlife Immobilization
7. DEPARTMENT OF VETERINARY PHYSIOLOGY, BIOCHEMISTRY AND PHARMACOLOGY POSTGRADUATE PROGRAMME
1.
Masters of Science in Veterinary Physiology
2. Masters in Veterinary Pharmacology
3. Masters in Veterinary Toxicology
4. Masters in
Veterinary Pharmacology
5.
MPhil/PhD. Philosophy in Veterinary Physiology
6. MPhil/PhD
Veterinary Pharmacology
7. MPhil/PhD Veterinary Toxicology
8. MPhil/PhD
Veterinary Physiology
CENTERS
CENTRE FOR CONFLICT MANAGEMENT AND PEACE STUDIES
1. M.Sc. Conflict Management and Peace studies
2. Postgraduate Diploma in Conflict Management and Peace Studies
3. MPhil/PhD Conflict Management and Peace Studies
6. CENTRE FOR GENDER AND WOMEN STUDIES
1. M.Phil/Ph.D. Women Studies
2. M.Phil/Ph.D. Gender Studies
3. M.A. Women Studies
4. M.Sc. Gender Studies
INSTITUTE OF EDUCATION
a. Postgraduate Diploma in Education (PGDE)
b.  Postgraduate Diploma in Technology Education (PGDTE)
Click to Download
Online Application Form
Postgraduate Programs
Programs
BSc. Statistics
4 years
Read more
BSc. Mathematics
Read more
M.Phil/Ph.D./MSc./PGD Mathematics
Read more
Postgraduate Staff
All Staff