Bulgarian Academy of Sciences

Address:

Bulgaria, Sofia, 1040
1 “15 Noemvri” Str.

Phone:

(+359 2) 979 53 33
(+359 2) 979 52 23

Registry Office:
Phone/Fax: 02 981 72 62
Phone: 02 979 52 63
E-mail: office@cu.bas.bg

Protocol:
Phone: (+359 2) 979 52 67
E-mail: emili@cu.bas.bg

Public Relations:
Phone: (+359 2) 979 52 80
E-mail: pr-ban@cu.bas.bg

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