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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