Promotional Material

{"map_options":{"center_lat":"27.790613","center_lng":"17.259926","zoom":2,"map_type_id":"ROADMAP","fit_bounds":false,"draggable":true,"scroll_wheel":true,"display_45_imagery":"","marker_default_icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","infowindow_setting":"","infowindow_bounce_animation":"","infowindow_drop_animation":false,"close_infowindow_on_map_click":false,"infowindow_skin":"","default_infowindow_open":false,"infowindow_open_event":"click","full_screen_control":true,"search_control":true,"zoom_control":true,"map_type_control":true,"street_view_control":true,"full_screen_control_position":"TOP_RIGHT","search_control_position":"TOP_LEFT","zoom_control_position":"TOP_LEFT","map_type_control_position":"TOP_RIGHT","map_type_control_style":"HORIZONTAL_BAR","street_view_control_position":"TOP_LEFT","map_control":true,"map_control_settings":false,"map_zoom_after_search":6,"width":"","height":"500"},"places":[{"id":"35","title":"Tunis, Tunisia (Coordinator: Habid Ben Boubaker)","address":"Tunis, Tunisia","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Tunis, Tunisia <\/span><br \/>\r\n<em>Coordinator: Habid Ben Boubaker<\/em>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/in-negotiation.png","lat":"36.8064948","lng":"10.181531599999971","city":"Tunis","state":"Tunis","country":"Tunisia","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"6","name":"In Negotiation","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/in-negotiation.png"}],"custom_filters":""},{"id":"39","title":"Bamako, Mali (Coordinator: Adama Samassekou)","address":"Bamako, Mali","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Bamako, Mali<\/span><br \/>\r\n<em>Coordinator: Adama Samassekou<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Bildschirmfoto-2016-06-28-um-13.36.232-e1467116036439.png\" \/>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/in-negotiation.png","lat":"12.6392316","lng":"-8.002889200000027","city":"Bamako","state":"Bamako","country":"Mali","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"6","name":"In Negotiation","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/in-negotiation.png"}],"custom_filters":""},{"id":"40","title":"Bras\u00edlia, Brazil (Coordinator: Sybelle de Jongh)","address":"Bras\u00edlia - Federal District, Brazil","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Bras\u00edlia, Brazil <\/span><br \/>\r\n<em>Coordinator: Sybelle de Jongh<\/em>\r\n\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Sybelle-Bild-e1467207323572.png\" \/>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.iyguamericalatina.org\">Website<\/a>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.facebook.com\/iyguamericalatina\/?fref=ts\">Facebook<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/continental_action_center.png","lat":"-15.7942287","lng":"-47.882165799999996","city":"Bras\u00edlia","state":"Federal District","country":"Brazil","onclick_action":"marker","redirect_custom_link":"https:\/\/www.facebook.com\/iyguamericalatina\/?fref=ts","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"7","name":"Continental Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/continental_action_center.png"}],"custom_filters":""},{"id":"41","title":"Washington, U.S.A. (Coordinator: Doug Richardson)","address":"Washington, DC, United States","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Washington, U.S.A<\/span><br \/>\r\n<em>Coordinator: Doug Richardson<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/AAG-2016-e1467210822335.jpg\" \/>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/AAG-IYGU-RAC-report-June-2016-1.pdf\">Download PDF<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/continental_action_center.png","lat":"38.9071923","lng":"-77.03687070000001","city":"Washington","state":"District of Columbia","country":"United States","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"7","name":"Continental Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/continental_action_center.png"}],"custom_filters":""},{"id":"43","title":"Santiago de Chile, Chile. (Coordinator: Enrique Aliste)","address":"Santiago, Chile","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Santiago de Chile, Chile<\/span><br \/>\r\n<em>Coordinator: Enrique Aliste<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/RAC_Chile.jpg\" \/>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/RAC_Chile.pdf\">Download PDF<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"-33.4378305","lng":"-70.65044920000003","city":"Santiago","state":"Santiago Metropolitan Region","country":"Chile","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"44","title":"Quebec, Canada (Coordinator: Steve D\u00e9ry)","address":"Qu\u00e9bec, Canada","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Quebec, Canada<\/span><br \/>\r\n<em>Coordinator: Steve D\u00e9ry<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/steve_dery_2014.png\" \/>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/canada-RAC.pdf\">Download PDF<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"52.9399159","lng":"-73.5491361","city":"","state":"Qu\u00e9bec","country":"Canada","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"45","title":"Beijing, P. R. China (Coordinator: Shangyi Zhou)","address":"Beijing, China","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Beijing, P. R. China<\/span><br \/>\r\n<em>Coordinator: Coordinator: Shangyi Zhou<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/RAC_Beijing.jpg\" \/>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Beijing-RAC.pdf\">Download PDF<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/continental_action_center.png","lat":"39.904211","lng":"116.40739499999995","city":"Beijing","state":"Beijing","country":"China","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"7","name":"Continental Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/continental_action_center.png"}],"custom_filters":""},{"id":"46","title":"New Delhi, India . (Coordinator: Deendayal Agrawal)","address":"New Dehli, Delhi, India","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">New Delhi, India <\/span><br \/>\r\n<em>Coordinator: Deendayal Agrawal<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/IMG_5890-e1467186211337.jpg\" \/>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/continental_action_center.png","lat":"28.6139391","lng":"77.20902120000005","city":"New Delhi","state":"Delhi","country":"India","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"110001","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"7","name":"Continental Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/continental_action_center.png"}],"custom_filters":""},{"id":"47","title":"Hiroshima, Japan. (Coordinator: Hidenori Okahashi \/ Yukio Himiyama)","address":"Hiroshima, Hiroshima Prefecture, Japan","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Hiroshima, Japan<\/span><br \/>\r\n<em>Coordinator: Hidenori Okahashi \/ Yukio Himiyama<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Japan-Logo-RAC-e1467205718118.png\" \/>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" a href=\"https:\/\/youtu.be\/U2dymY506EM\">Show video<\/a>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" a href=\"http:\/\/home.hiroshima-u.ac.jp\/iygu\/index.html\">Website<\/a>\r\n\r\n","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"34.3852029","lng":"132.45529269999997","city":"Hiroshima","state":"Hiroshima Prefecture","country":"Japan","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"48","title":"Taipei, Taiwan (Coordinator: Shew-Jiuan Su)","address":"Taipei, Taiwan","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Taipei, Taiwan<\/span><br \/>\r\n<em>Coordinator: Shew-Jiuan Su<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/RAC_Taiwanese.jpg\" \/>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"25.0329694","lng":"121.56541770000001","city":"Taipei","state":"Taipei City","country":"Taiwan","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"49","title":"Leipzig, Germany (Coordinator: Francis Harvey)","address":"Leipzig, Germany","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Leipzig, Germany<\/span><br \/>\r\n<em>Coordinator: Francis Harvey<\/em>\r\nor <a style=\"color:#9ead12;\" target=\"_blank\" href=\"https:\/\/www.ifl-leipzig.de\/de\/aktuell\/iygu.html\">visit Website<\/a>\r\n","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/continental_action_center.png","lat":"51.3396955","lng":"12.373074699999961","city":"Leipzig","state":"Saxony","country":"Germany","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"7","name":"Continental Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/continental_action_center.png"}],"custom_filters":""},{"id":"50","title":"Kiev, Ukraine. (Coordinator: Yaroslaw Oliynyk)","address":"Kiev, Kyiv city, Ukraine","source":"manual","content":"Kiev, Ukraine. (Coordinator: Yaroslaw Oliynyk)","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"50.4501","lng":"30.523400000000038","city":"Kiev","state":"Kyiv city","country":"Ukraine","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"02000","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"51","title":"Vilnius, Lithuania. (Coordinators: Dovil\u0117 Krupickait\u0117 \/ Renaldas Gudaukas)","address":"Vilnius, Vilnius County, Lithuania","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Vilnius, Lithuania<\/span><br \/>\r\n<em>Coordinators: Dovil\u0117 Krupickait\u0117\/Renaldas Gudaukas<\/em>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Lithuania.pdf\">Download PDF<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"54.6871555","lng":"25.279651400000034","city":"Vilnius","state":"Vilnius County","country":"Lithuania","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"52","title":"Ma\u00e7\u00e3o\/Coimbra, Portugal (Coordinator: Maria Helena Henriques)","address":"Coimbra, Portugal","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Ma\u00e7\u00e3o\/Coimbra, Portugal <\/span><br \/>\r\n<em>Coordinator: Maria Helena Henriques<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/DSC_0120_Trumpp-e1467188086149.jpg\" \/>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" a href=\"https:\/\/www.youtube.com\/watch?v=WIHNc3Y2a2M\">Show video<\/a>\r\nor <a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.entendimentoglobal.ipt.pt\">visit Website<\/a>\r\n\r\n\r\n\r\n","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/continental_action_center.png","lat":"40.2048286","lng":"-8.44035729999996","city":"","state":"Coimbra District","country":"Portugal","onclick_action":"marker","redirect_custom_link":"http:\/\/www.entendimentoglobal.ipt.pt\/","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"7","name":"Continental Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/continental_action_center.png"}],"custom_filters":""},{"id":"53","title":"Santiago de Compostela, Spain. (Coordinators: Ruben Gonzales \/ M.J. Pineira)","address":"Santiago de Compostela, Spain","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Santiago de Compostela, Spain<\/span><br \/>\r\n<em>Coordinators: Ruben Gonzales \/ M.J. Pineira<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/RAC_SantiagoDeCompostelaSpain.jpg\" \/>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Video-of-presentation-of-the-RAC-in-Spain.pdf\">Download PDF<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"42.8782132","lng":"-8.544844499999954","city":"Santiago","state":"Galicia","country":"Spain","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"54","title":"Nijmegen, The Netherlands. (Coordinator: Huib Ernste)","address":"Nijmegen, Netherlands","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Nijmegen, The Netherlands<\/span><br \/>\r\n<em>Coordinator: Huib Ernste<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Bildschirmfoto-2016-06-28-um-14.35.43-e1467117389846.png\" \/>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/in-negotiation.png","lat":"51.8125626","lng":"5.837226399999963","city":"Nijmegen","state":"Gelderland","country":"Netherlands","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"6","name":"In Negotiation","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/in-negotiation.png"}],"custom_filters":""},{"id":"55","title":"Athens, Greece. (Coordinator: Anastasia Stratigea)","address":"Athens, Kentrikos Tomeas Athinon, Greece","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Athens, Greece<\/span><br \/>\r\n<em>Coordinator: Anastasia Stratigea<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/RAC_GR.jpg\" \/>\r\n<a target=\"_blank\" style=\"color:#9ead12;\" href=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/RAC_GR_WORK_PHOTOS_Description.pdf\">Download PDF Work<\/a>,  <a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/RAC_GR_REPORT_PHOTOS_revised.pdf\">Download PDF Report<\/a> or\r\n<a style=\"color:#9ead12;\" target=\"_blank\" href=\"https:\/\/www.youtube.com\/watch?v=sh-GNEU5t2U\">show Video <\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"37.98391699999999","lng":"23.729359899999963","city":"Kentrikos Tomeas Athinon","state":"Attica","country":"Greece","onclick_action":"marker","redirect_custom_link":"http:\/\/iygu.ntua.gr\/","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"56","title":"Ljubljana, Slovenia. (Coordinator: Katja Vintar Mally)","address":"Ljubljana, Slovenia","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Ljubljana, Slovenia<\/span><br \/>\r\n<em>Coordinator: Katja Vintar Mally<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/slovenia.jpg\" \/>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/RAC-Ljubljana-Slovenia.pdf\">Download PDF<\/a>\r\n\r\nor <a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/geo.ff.uni-lj.si\/IYGU\">visit Website<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"46.0569465","lng":"14.505751499999974","city":"Ljubljana","state":"Ljubljana","country":"Slovenia","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"57","title":"Zagreb, Croatia. (Coordinator: Borna Fuerst Bjelis)","address":"Zagreb, Croatia","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Zagreb, Croatia <\/span><br \/>\r\n<em>Coordinator: Borna Fuerst Bjelis<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Zgrada-university-building-e1467187330938.jpg\"\/>\r\n<a href=\"https:\/\/www.youtube.com\/watch?v=AP2jiCGsKtc\">Show video<\/a>\r\n<a href=\"https:\/\/www.pmf.unizg.hr\/geog\/iygu\">Website<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"45.8150108","lng":"15.981919000000062","city":"Zagreb","state":"City of Zagreb","country":"Croatia","onclick_action":"marker","redirect_custom_link":"https:\/\/www.pmf.unizg.hr\/geog\/iygu","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"58","title":"Melbourne, Australia. (Coordinator: Margaret Robertson)","address":"Melbourne, Victoria, Australia","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Melbourne, Australia<\/span><br \/>\r\n<em>Coordinator: Margaret Robertson<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/melbourne-RAC-e1466776285194.png\" \/>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Australia-RAC1.pdf\">Download PDF<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/continental_action_center.png","lat":"-37.814107","lng":"144.96327999999994","city":"Melbourne","state":"Victoria","country":"Australia","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"7","name":"Continental Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/continental_action_center.png"}],"custom_filters":""},{"id":"79","title":"Minia, Egypt. (Coordinator: Gamal-Eldin Ali Abou-Elmagd\/Edrees Sultan)","address":"Minya, Egypt","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Minia, Egypt<\/span><br \/>\r\n<em>Coordinator: Edrees Sultan Saleh <\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Edrees-Sultan.jpg\" \/>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Egypt-RAC.pdf\">Download PDF<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/in-negotiation.png","lat":"28.2501605","lng":"29.974053400000003","city":"","state":"Menia Governorate","country":"Egypt","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"6","name":"In Negotiation","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/in-negotiation.png"}],"custom_filters":""},{"id":"80","title":"Ibadan, Nigeria. (Coordinator: Ibidun Adenelkan)","address":"Ibadan, Oyo, Nigeria","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Ibadan,  Nigeria<\/span><br \/>\r\n<em>Coordinator: Dr Ibidun  Adelekan <\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Ibidun-Photo-e1466769778123.jpg\" \/>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Nigeria-RAC.pdf\">Download PDF<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"7.377535500000001","lng":"3.947039600000039","city":"Ibadan","state":"Oyo","country":"Nigeria","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"81","title":"Buenos Aires, Argentina. (Coordinator: Perla Zusman)","address":"Buenos Aires, Autonomous City of Buenos Aires, Argentina","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Buenos Aires, Argentina<\/span><br \/>\r\n<em>Coordinator: Perla Zusman<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Fachada-Filo-e1467117103725.jpg\" \/>\r\n<a style=\"color:#9ead12;\" target=\"http:\/\/www.global-understanding.info\/?p=4018\">Download PDF<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/in-negotiation.png","lat":"-34.60368440000001","lng":"-58.381559100000004","city":"Buenos Aires","state":"Autonomous City of Buenos Aires","country":"Argentina","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"6","name":"In Negotiation","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/in-negotiation.png"}],"custom_filters":""},{"id":"82","title":"Qatar. (Coordinator: Rupert Maclean)","address":"Qatar","source":"manual","content":"Qatar. (Coordinator: Rupert Maclean)","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/in-negotiation.png","lat":"25.354826","lng":"51.183884000000035","city":"","state":"","country":"Qatar","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"6","name":"In Negotiation","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/in-negotiation.png"}],"custom_filters":""},{"id":"83","title":"Teheran, Iran. (Coordinator: Homa Rashid)","address":"SDS International Group, Zafar St, Tehran, Iran","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Teheran, Iran<\/span><br \/>\r\n<em>Coordinator: Homa Rashid<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/iran1.jpg\" \/>\r\n<a style=\"color:#9ead12;\" target=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/RAC_Tehran_Iran.pdf\">Download PDF<\/a>\r\n<a href=\"http:\/\/rac.sdsgroup.org\/pages\/?catid=156\">Website<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"35.7673034","lng":"51.42511239999999","city":"Tehran","state":"Tehran","country":"Iran","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"84","title":"Riyadh, the Kingdom of Saudi Arabia. (Coordinator: Mohammed Shawqi Makki)","address":"Riyadh, Riyadh Province, Saudi Arabia","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Riyadh, the Kingdom of Saudi Arabia<\/span><br \/>\r\n<em>Coordinator: Mohammed Shawqi Makki<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/IMG-20160419-WA0027_resized-e1467200888734.jpg\" \/>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/saudi-RAC.pdf\">Download PDF<\/a>\r\n","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/national-center.png","lat":"24.7135517","lng":"46.67529569999999","city":"Riyadh","state":"Riyadh Province","country":"Saudi Arabia","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"5","name":"National Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/national-center.png"}],"custom_filters":""},{"id":"85","title":"Genoa : Regional Action Center \u2013 Italy. (Coordinator: Franco Montanari \/ Michele Piana)","address":"Genoa, Metropolitan City of Genoa, Italy","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Genoa, Italy. <\/span><br \/>\r\n<em>Coordinator: Franco Montanari \/ Michele Piana<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/RAC_GR.jpg\" \/>\r\n<a target=\"_blank\" style=\"color:#9ead12;\" href=\"https:\/\/youtu.be\/5soK32BDip8\">Show Video<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"44.4056499","lng":"8.946255999999948","city":"Genoa","state":"Liguria","country":"Italy","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"86","title":"Cheongju, South Korea. (Coordinator: Je-Hun Ryu)","address":"Cheongju-si, Chungcheongbuk-do, South Korea","source":"manual","content":"Cheongju, South Korea. (Coordinator: Je-Hun Ryu)","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"36.6424341","lng":"127.48903189999999","city":"Cheongju-si","state":"Chungcheongbuk-do","country":"South Korea","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"87","title":"Moscow, Russia. (Coordinator:Vladimir Kolossov)","address":"Moscow, Russia","source":"manual","content":"Moscow, Russia. (Coordinator:Vladimir Kolossov)","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"55.755826","lng":"37.6173","city":"Moscow","state":"Moscow","country":"Russia","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"90","title":"Hamilton, New Zealand. (Coordinator: Robyn Longhurst)","address":"Hamilton, Waikato, New Zealand","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Hamilton, New Zealand<\/span><br \/>\r\n<em>Coordinator: Robyn Longhurst<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/RAC_WaikatoNewZealand.jpg\" \/>\r\n<a style=\"color:#9ead12;\" target=\"RAC_WaikatoNewZealand.pdf\">Download PDF<\/a> or <a style=\"color:#9ead12;\" target=\"https:\/\/www.youtube.com\/watch?v=yUKF7gHIBKs\">show video<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"-37.7870012","lng":"175.27925300000004","city":"Hamilton","state":"Waikato","country":"New Zealand","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"93","title":"Lueneburg, Germany (Coordinator: Ulli Vilsmaier)","address":"Leuphana University Lueneburg, Scharnhorststra\u00dfe, L\u00fcneburg, Germany","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Lueneburg, Germany<\/span><br \/>\r\n<em>Coordinator: Ulli Vilsmaier<\/em>\r\nor <a style=\"color:#9ead12;\" target=\"_blank\" href=\"https:\/\/www.leuphana.de\/zentren\/cgsc\/international-year-of-global-understanding-iygu\/regional-action-center-germany.html\">visit Website<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"53.228844","lng":"10.401219999999967","city":"L\u00fcneburg","state":"","country":"Germany","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"21335","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"100","title":"Paris, France (Coordinator - Margalit Berriet)","address":"45\/47 Rue Ramponeau, 75020 Paris, France","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\">Paris, France<\/span><br \/>\r\n<em>Coordinator: Margalit Berriet<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Memoire-de-lAvenir-e1466771104428.png\" \/>\r\n<a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/Margalit-Berriet-RAC2.pdf\">Download PDF<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"48.8718347","lng":"2.38157369999999","city":"Paris","state":"\u00cele-de-France","country":"France","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"75020","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"101","title":"Skopje: Regional Action Center \u2013 Macedonia. (Coordinator: Biljana Apostolovska Toshevska)","address":"Arhimedova 3, Skopje 1000, Macedonia (FYROM)","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\"> Skopje, Macedonia <\/span><br \/>\r\n<em>Coordinator: Biljana Apostolovska Toshevska<\/em>\r\n<img src=\"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/07\/Biljana-Apostolovska-Toshevska-e1468400051871.jpg\" \/>\r\nor <a style=\"color:#9ead12;\" target=\"_blank\" href=\"http:\/\/www.mgd.mk\/\">visit Website<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"42.00124479999999","lng":"21.450682899999947","city":"Skopje","state":"Skopje","country":"Macedonia (FYROM)","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"1000","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"102","title":"Belgrade: Regional Action Center \u2013 Serbia. (Coordinator: Emilija Manic)","address":"","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\"> Belgrade, Serbia <\/span><br \/>\r\n<em>Coordinator: Emilija Manic<\/em>\r\n<a href=\"http:\/\/sgd.org.rs\/sr\/iygu\/\">Website<\/a>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/in-negotiation.png","lat":"44.819059","lng":"20.456855","city":"","state":"","country":"","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"6","name":"In Negotiation","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/uploads\/2016\/06\/in-negotiation.png"}],"custom_filters":""},{"id":"103","title":"Istanbul: Regional Action Center \u2013 Turkey. (Coordinators: Barbaros G\u00f6nen\u00e7gil, Tolga G\u00f6r\u00fcm)","address":"Beyaz\u0131t Mahallesi, Foto Beyazit, Fatih\/\u0130stanbul, Turkey","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\"> Istanbul, Turkey<\/span><br \/>\r\n<em>Coordinator: Barbaros G\u00f6nen\u00e7gil, Tolga G\u00f6r\u00fcm<\/em>\r\n","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"41.015178550653616","lng":"28.959909846496544","city":"","state":"\u0130stanbul","country":"Turkey","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"34134","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""},{"id":"104","title":"Warsaw: Regional Action Center \u2013 Poland.","address":"Defilad 1 00-901 Warsaw, Poland","source":"manual","content":"<span style=\"font-size:18px;font-weight:bold;\"> Warsaw, Poland<\/span><br \/>\r\n<em>Coordinator: Katarzyna Iwinska<\/em>","location":{"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png","lat":"52.232627","lng":"21.005909","city":"","state":"","country":"","onclick_action":"marker","redirect_custom_link":"","marker_image":"","open_new_tab":"yes","postal_code":"","draggable":false,"infowindow_default_open":false,"animation":"BOUNCE","infowindow_disable":true,"zoom":5,"extra_fields":""},"categories":[{"id":"4","name":"Regional Action Center","type":"category","extension_fields":[],"icon":"http:\/\/www.global-understanding.info\/wp-content\/plugins\/wp-google-map-plugin\/\/assets\/images\/icons\/pin_green.png"}],"custom_filters":""}],"styles":"","listing":"","marker_cluster":"","map_property":{"map_id":"2","debug_mode":false}}

In Negotiation

Future Earth Center

Continental Action Center Center

Regional Action Center

Regional Action Program

Merken