AEFE

{"map_options":{"center_lat":"41.8896563","center_lng":"12.4792108","zoom":7,"map_type_id":"HYBRID","center_by_nearest":false,"fit_bounds":false,"center_circle_fillcolor":"#8CAEF2","center_circle_strokecolor":"#8CAEF2","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","draggable":true,"scroll_wheel":"true","gesture":"auto","marker_default_icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/11-generic.png","infowindow_setting":"<div class=\"fc-main\">\n<div class=\"fc-item-title\">{marker_title} <span class=\"fc-badge info\">{marker_category}<\/span><\/div>\n<div class=\"fc-item-featured_image\">{marker_image} <\/div>\n<p>{marker_message}<\/p>\n<address><b>Address : <\/b>{marker_address}<\/address>\n<\/div>\n","infowindow_geotags_setting":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{post_title}<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                {post_excerpt}\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div>{post_featured_image}<div id=\"contenu_article\">{post_content}<\/div><\/div>","infowindow_skin":{"name":"default","type":"infowindow","sourcecode":"&lt;div class=&quot;fc-main&quot;&gt;&lt;div class=&quot;fc-item-title&quot;&gt;{marker_title} &lt;span class=&quot;fc-badge info&quot;&gt;{marker_category}&lt;\/span&gt;&lt;\/div&gt; &lt;div class=&quot;fc-item-featured_image&quot;&gt;{marker_image} &lt;\/div&gt;{marker_message}&lt;address&gt;&lt;b&gt;Address : &lt;\/b&gt;{marker_address}&lt;\/address&gt;&lt;\/div&gt;"},"infowindow_post_skin":{"name":"udine","type":"post","sourcecode":"&lt;div class=&quot;fc-item-box fc-item-no-padding&quot;&gt;\r\n    &lt;div class=&quot;fc-itemcontent-padding&quot;&gt;\r\n        &lt;div class=&quot;fc-item-padding-content_20&quot;&gt;\r\n            &lt;div class=&quot;fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center&quot;&gt;&lt;\/div&gt;\r\n            &lt;div class=&quot;fc-item-title fc-item-primary-text-color fc-text-center&quot;&gt;{post_title}&lt;\/div&gt;\r\n            &lt;div class=&quot;fc-item-content fc-item-body-text-color fc-item-top-space&quot;&gt;\r\n                {post_excerpt}\r\n&lt;p style=&quot;text-align:center;&quot;&gt;&lt;button onclick=&quot;javascript:affiche_post();&quot;&gt;EN SAVOIR PLUS&lt;\/button&gt;&lt;\/p&gt;\r\n            &lt;\/div&gt;\r\n        &lt;\/div&gt;\r\n    &lt;\/div&gt;\r\n&lt;\/div&gt;\r\n&lt;div id=&quot;contenu_post&quot; style=&quot;display:none;&quot;&gt;&lt;div id=&quot;btFermePost&quot;&gt;&lt;button onclick=&quot;javascript:fermer_post();&quot;&gt;&lt;small&gt;Fermer&lt;\/small&gt;&lt;\/button&gt;&lt;\/div&gt;{post_featured_image}&lt;div id=&quot;contenu_article&quot;&gt;{post_content}&lt;\/div&gt;&lt;\/div&gt;"},"infowindow_drop_animation":false,"close_infowindow_on_map_click":false,"default_infowindow_open":false,"infowindow_open_event":"mouseover","infowindow_filter_only":false,"infowindow_click_change_zoom":0,"infowindow_click_change_center":false,"full_screen_control":false,"search_control":true,"zoom_control":true,"map_type_control":false,"street_view_control":false,"locateme_control":false,"mobile_specific":false,"zoom_mobile":5,"draggable_mobile":true,"scroll_wheel_mobile":true,"full_screen_control_position":"TOP_RIGHT","search_control_position":"TOP_LEFT","locateme_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":false,"screens":{"smartphones":{"map_zoom_level_mobile":"5"},"ipads":{"map_zoom_level_mobile":"5"},"large-screens":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":false,"infowindow_width":"100%","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#fff","show_infowindow_header":false,"min_zoom":"0","max_zoom":"19","zoom_level_after_search":"10","url_filters":false,"doubleclickzoom":false,"current_post_only":false,"bound_map_after_filter":true,"display_reset_button":true,"map_reset_button_text":"R\u00e9initialiser","height":"600"},"places":[{"source":"post","title":"\u00eele Tib\u00e9rine","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">\u00eele Tib\u00e9rine<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Rome \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\n\u00eele Tib\u00e9rine<\/h2>\n<p>Latitude : 41.8896563|Longitude : 12.4792108<br \/>Commune : Rome<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-16Fm.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-16FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Rome \u2022 2023-2024","address":"","location":{"lat":"41.8896563","lng":"12.4792108","redirect_custom_link":"","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-tiberine\/","zoom":7,"extra_fields":{"post_excerpt":"Rome \u2022 2023-2024","post_content":"<h2 class=\"site\">\n\u00eele Tib\u00e9rine<\/h2>\n<p>Latitude : 41.8896563|Longitude : 12.4792108<br \/>Commune : Rome<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-16Fm.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-16FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"\u00eele Tib\u00e9rine","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-tiberine\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"41.8896563","%_wpgmp_metabox_longitude%":"12.4792108","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_16","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13205,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Battersea bridge","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Battersea bridge<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Rome \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nBattersea bridge<\/h2>\n<p>Latitude : 41.7389353|Longitude : 12.2381849<br \/>Commune : Rome<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-17FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-17FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Rome \u2022 2023-2024","location":{"lat":"41.7389353","lng":"12.2381849","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/battersea-bridge-2\/","zoom":7,"extra_fields":{"post_excerpt":"Rome \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBattersea bridge<\/h2>\n<p>Latitude : 41.7389353|Longitude : 12.2381849<br \/>Commune : Rome<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-17FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-17FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Battersea bridge","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/battersea-bridge-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"41.7389353","%_wpgmp_metabox_longitude%":"12.2381849","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_17","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13206,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Lyc\u00e9e Chateaubriand","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Chateaubriand<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Cycle 3 et 4\u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Chateaubriand<\/h2>\n<p>Commune\u00a0: Rome<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Cycle 3 et 4<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites \u00eele Tib\u00e9rine et Battersea bridge.\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-16Fm.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-16FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-17FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-17FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Cycle 3 et 4\u2022 2023-2024","location":{"lat":"41.909630881348164","lng":"12.506022454130822","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-chateaubriand\/","zoom":7,"extra_fields":{"post_excerpt":"Cycle 3 et 4\u2022 2023-2024","post_content":"<h2>Lyc\u00e9e Chateaubriand<\/h2>\n<p>Commune\u00a0: Rome<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Cycle 3 et 4<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites \u00eele Tib\u00e9rine et Battersea bridge.\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-16Fm.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-16FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-17FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-17FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Lyc\u00e9e Chateaubriand","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-chateaubriand\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"41.909630881348164","%_wpgmp_metabox_longitude%":"12.506022454130822","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_16#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":13207,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"K\u0131s\u0131rka Village Beach","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">K\u0131s\u0131rka Village Beach<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                K\u0131s\u0131rkaya, Sar\u0131yer Mahallesi (arrondissement) \u2022 2024-2025\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nK\u0131s\u0131rka Village Beach<\/h2>\n<p>Latitude : 41.252925|Longitude : 28.972966<br \/>Commune : K\u0131s\u0131rkaya, Sar\u0131yer Mahallesi (arrondissement)<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p><\/div><\/div>","content":"K\u0131s\u0131rkaya, Sar\u0131yer Mahallesi (arrondissement) \u2022 2024-2025","location":{"lat":"41.252925","lng":"28.972966","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/kisirka-village-beach\/","zoom":7,"extra_fields":{"post_excerpt":"K\u0131s\u0131rkaya, Sar\u0131yer Mahallesi (arrondissement) \u2022 2024-2025","post_content":"<h2 class=\"site\">\nK\u0131s\u0131rka Village Beach<\/h2>\n<p>Latitude : 41.252925|Longitude : 28.972966<br \/>Commune : K\u0131s\u0131rkaya, Sar\u0131yer Mahallesi (arrondissement)<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p>","post_title":"K\u0131s\u0131rka Village Beach","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/kisirka-village-beach\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"41.252925","%_wpgmp_metabox_longitude%":"28.972966","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_7","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2024-2025"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13212,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2024-2025"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Suma Beach Kumk\u00f6y","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Suma Beach Kumk\u00f6y<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                K\u0131s\u0131rkaya, Sar\u0131yer Mahallesi (arrondissement) \u2022 2024-2025\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nSuma Beach Kumk\u00f6y<\/h2>\n<p>Latitude : 41.245694|Longitude : 29.030767<br \/>Commune : K\u0131s\u0131rkaya, Sar\u0131yer Mahallesi (arrondissement)<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p><\/div><\/div>","content":"K\u0131s\u0131rkaya, Sar\u0131yer Mahallesi (arrondissement) \u2022 2024-2025","location":{"lat":"41.245694","lng":"29.030767","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/suma-beach-kumkoy\/","zoom":7,"extra_fields":{"post_excerpt":"K\u0131s\u0131rkaya, Sar\u0131yer Mahallesi (arrondissement) \u2022 2024-2025","post_content":"<h2 class=\"site\">\nSuma Beach Kumk\u00f6y<\/h2>\n<p>Latitude : 41.245694|Longitude : 29.030767<br \/>Commune : K\u0131s\u0131rkaya, Sar\u0131yer Mahallesi (arrondissement)<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p>","post_title":"Suma Beach Kumk\u00f6y","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/suma-beach-kumkoy\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"41.245694","%_wpgmp_metabox_longitude%":"29.030767","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_8","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2024-2025"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13213,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2024-2025"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Rumeli Kava\u011f\u0131","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Rumeli Kava\u011f\u0131<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                K\u0131s\u0131rkaya, Sar\u0131yer Mahallesi (arrondissement) \u2022 2024-2025\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nRumeli Kava\u011f\u0131<\/h2>\n<p>Latitude : 41.185385|Longitude : 29.076884<br \/>Commune : K\u0131s\u0131rkaya, Sar\u0131yer Mahallesi (arrondissement)<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p><\/div><\/div>","content":"K\u0131s\u0131rkaya, Sar\u0131yer Mahallesi (arrondissement) \u2022 2024-2025","location":{"lat":"41.185385","lng":"29.076884","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/rumeli-kavagi\/","zoom":7,"extra_fields":{"post_excerpt":"K\u0131s\u0131rkaya, Sar\u0131yer Mahallesi (arrondissement) \u2022 2024-2025","post_content":"<h2 class=\"site\">\nRumeli Kava\u011f\u0131<\/h2>\n<p>Latitude : 41.185385|Longitude : 29.076884<br \/>Commune : K\u0131s\u0131rkaya, Sar\u0131yer Mahallesi (arrondissement)<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p>","post_title":"Rumeli Kava\u011f\u0131","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/rumeli-kavagi\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"41.185385","%_wpgmp_metabox_longitude%":"29.076884","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_9","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2024-2025"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13214,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2024-2025"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Lyc\u00e9e Pierre Loti","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Pierre Loti<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Une classe 2nde \u2022 2024-2025\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Pierre Loti<\/h2>\n<p>Commune\u00a0: ISTANBUL<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2024-2025<\/h3>\n<h4>100 \u00e9l\u00e8ves de Une classe 2nde, 5\u00e8me et 6\u00e8me + groupe des \u00e9cod\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site K\u0131s\u0131rka Village Beach. Les donn\u00e9es seront mises en ligne en mai 2025.<\/p><\/div><\/div>","content":"Une classe 2nde \u2022 2024-2025","location":{"lat":"41.14293014254559","lng":"29.0552792540878","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-pierre-loti\/","zoom":7,"extra_fields":{"post_excerpt":"Une classe 2nde \u2022 2024-2025","post_content":"<h2>Lyc\u00e9e Pierre Loti<\/h2>\n<p>Commune\u00a0: ISTANBUL<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2024-2025<\/h3>\n<h4>100 \u00e9l\u00e8ves de Une classe 2nde, 5\u00e8me et 6\u00e8me + groupe des \u00e9cod\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site K\u0131s\u0131rka Village Beach. Les donn\u00e9es seront mises en ligne en mai 2025.<\/p>","post_title":"Lyc\u00e9e Pierre Loti","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-pierre-loti\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"41.14293014254559","%_wpgmp_metabox_longitude%":"29.0552792540878","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_7#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2024-2025"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":13215,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2024-2025"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Barrio de Jes\u00fas","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Barrio de Jes\u00fas<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saragosse \u2022 2024-2025\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nBarrio de Jes\u00fas<\/h2>\n<p>Latitude : 41.654722|Longitude : -0.866389<br \/>Commune : Saragosse<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p><\/div><\/div>","content":"Saragosse \u2022 2024-2025","location":{"lat":"41.654722","lng":"-0.866389","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/barrio-de-jesus\/","zoom":7,"extra_fields":{"post_excerpt":"Saragosse \u2022 2024-2025","post_content":"<h2 class=\"site\">\nBarrio de Jes\u00fas<\/h2>\n<p>Latitude : 41.654722|Longitude : -0.866389<br \/>Commune : Saragosse<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p>","post_title":"Barrio de Jes\u00fas","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/barrio-de-jesus\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"41.654722","%_wpgmp_metabox_longitude%":"-0.866389","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_15","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2024-2025"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13199,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2024-2025"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Lyc\u00e9e Moli\u00e8re de Saragosse","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Moli\u00e8re de Saragosse<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Enseignement scientifique \/ Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2024-2025\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Moli\u00e8re de Saragosse<\/h2>\n<p>Commune\u00a0: Zaragoza<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2024-2025<\/h3>\n<h4>12 \u00e9l\u00e8ves de Enseignement scientifique \/ Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Helios. Les donn\u00e9es seront mises en ligne en mai 2025.<\/p><\/div><\/div>","content":"Enseignement scientifique \/ Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2024-2025","location":{"lat":"41.662352276394294","lng":"-0.8825752863561522","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-moliere-de-saragosse\/","zoom":7,"extra_fields":{"post_excerpt":"Enseignement scientifique \/ Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2024-2025","post_content":"<h2>Lyc\u00e9e Moli\u00e8re de Saragosse<\/h2>\n<p>Commune\u00a0: Zaragoza<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2024-2025<\/h3>\n<h4>12 \u00e9l\u00e8ves de Enseignement scientifique \/ Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Helios. Les donn\u00e9es seront mises en ligne en mai 2025.<\/p>","post_title":"Lyc\u00e9e Moli\u00e8re de Saragosse","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-moliere-de-saragosse\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"41.662352276394294","%_wpgmp_metabox_longitude%":"-0.8825752863561522","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_15#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2024-2025"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":13200,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2024-2025"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Wapping Beach","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Wapping Beach<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Londres \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nWapping Beach<\/h2>\n<p>Latitude : 51.5075000|Longitude : 0.0502500<br \/>Commune : Londres<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Londres \u2022 2023-2024","location":{"lat":"51.5075000","lng":"0.0502500","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/wapping-beach\/","zoom":7,"extra_fields":{"post_excerpt":"Londres \u2022 2023-2024","post_content":"<h2 class=\"site\">\nWapping Beach<\/h2>\n<p>Latitude : 51.5075000|Longitude : 0.0502500<br \/>Commune : Londres<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Wapping Beach","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/wapping-beach\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"51.5075000","%_wpgmp_metabox_longitude%":"0.0502500","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_10","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13201,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Ratcliffe Cross Stairs","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Ratcliffe Cross Stairs<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Londres \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nRatcliffe Cross Stairs<\/h2>\n<p>Latitude : 51.5097500|Longitude : 0.0414444<br \/>Commune : Londres<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Londres \u2022 2023-2024","location":{"lat":"51.5097500","lng":"0.0414444","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ratcliffe-cross-stairs\/","zoom":7,"extra_fields":{"post_excerpt":"Londres \u2022 2023-2024","post_content":"<h2 class=\"site\">\nRatcliffe Cross Stairs<\/h2>\n<p>Latitude : 51.5097500|Longitude : 0.0414444<br \/>Commune : Londres<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Ratcliffe Cross Stairs","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ratcliffe-cross-stairs\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"51.5097500","%_wpgmp_metabox_longitude%":"0.0414444","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_11","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13202,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Battersea bridge","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Battersea bridge<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Londres \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nBattersea bridge<\/h2>\n<p>Latitude : 51.4802500|Longitude : 0.1721389<br \/>Commune : Londres<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-12FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Londres \u2022 2023-2024","location":{"lat":"51.4802500","lng":"0.1721389","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/battersea-bridge\/","zoom":7,"extra_fields":{"post_excerpt":"Londres \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBattersea bridge<\/h2>\n<p>Latitude : 51.4802500|Longitude : 0.1721389<br \/>Commune : Londres<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-12FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Battersea bridge","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/battersea-bridge\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"51.4802500","%_wpgmp_metabox_longitude%":"0.1721389","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_12","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13203,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Lyc\u00e9e Fran\u00e7ais Charles de Gaulle","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Fran\u00e7ais Charles de Gaulle<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coll\u00e8ge lyc\u00e9e \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Fran\u00e7ais Charles de Gaulle<\/h2>\n<p>Commune\u00a0: Londres<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Coll\u00e8ge lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le trois sites \u00e0 Londres. \n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-12FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Coll\u00e8ge lyc\u00e9e \u2022 2023-2024","location":{"lat":"51.495464501075254","lng":"-0.1766590532074371","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-francais-charles-de-gaulle\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge lyc\u00e9e \u2022 2023-2024","post_content":"<h2>Lyc\u00e9e Fran\u00e7ais Charles de Gaulle<\/h2>\n<p>Commune\u00a0: Londres<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Coll\u00e8ge lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le trois sites \u00e0 Londres. \n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-11FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-11FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-12FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Lyc\u00e9e Fran\u00e7ais Charles de Gaulle","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-francais-charles-de-gaulle\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"51.495464501075254","%_wpgmp_metabox_longitude%":"-0.1766590532074371","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_10#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":13204,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Mangalsala","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Mangalsala<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Riga \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nMangalsala<\/h2>\n<p>Latitude : 57.0574199|Longitude : 24.0470978<br \/>Commune : Riga<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-18FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-18FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Riga \u2022 2023-2024","location":{"lat":"57.0574199","lng":"24.0470978","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/mangalsala\/","zoom":7,"extra_fields":{"post_excerpt":"Riga \u2022 2023-2024","post_content":"<h2 class=\"site\">\nMangalsala<\/h2>\n<p>Latitude : 57.0574199|Longitude : 24.0470978<br \/>Commune : Riga<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-18FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-18FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Mangalsala","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/mangalsala\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"57.0574199","%_wpgmp_metabox_longitude%":"24.0470978","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_18","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13185,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Kipsala","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Kipsala<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Riga \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nKipsala<\/h2>\n<p>Latitude : 56.9517081|Longitude : 24.0904138<br \/>Commune : Riga<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-19FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-19FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Riga \u2022 2023-2024","location":{"lat":"56.9517081","lng":"24.0904138","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/kipsala\/","zoom":7,"extra_fields":{"post_excerpt":"Riga \u2022 2023-2024","post_content":"<h2 class=\"site\">\nKipsala<\/h2>\n<p>Latitude : 56.9517081|Longitude : 24.0904138<br \/>Commune : Riga<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-19FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-19FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Kipsala","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/kipsala\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"56.9517081","%_wpgmp_metabox_longitude%":"24.0904138","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_19","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13186,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Maskavas-Forstate","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Maskavas-Forstate<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Riga \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nMaskavas-Forstate<\/h2>\n<p>Latitude : 56,93331.|Longitude : 24.1341788<br \/>Commune : Riga<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-20FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Riga \u2022 2023-2024","location":{"lat":"56.93331","lng":"24.1341788","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/maskavas-forstate\/","zoom":7,"extra_fields":{"post_excerpt":"Riga \u2022 2023-2024","post_content":"<h2 class=\"site\">\nMaskavas-Forstate<\/h2>\n<p>Latitude : 56,93331.|Longitude : 24.1341788<br \/>Commune : Riga<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-20FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Maskavas-Forstate","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/maskavas-forstate\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"56.93331","%_wpgmp_metabox_longitude%":"24.1341788","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_20","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13187,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"\u00c9cole fran\u00e7aise Jules Verne de Riga","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">\u00c9cole fran\u00e7aise Jules Verne de Riga<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6e et 2nd \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>\u00c9cole fran\u00e7aise Jules Verne de Riga<\/h2>\n<p>Commune\u00a0: Riga<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>90 \u00e9l\u00e8ves de 6e et 2nd<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites Mangalsala, Kipsala et Maskavas-Fortstate. \"<ul><li><a rel=\"\"noreferrer noopener\"\" <ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-18FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-18FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-19FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-19FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-20FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"6e et 2nd \u2022 2023-2024","location":{"lat":"56.98891962499646","lng":"24.135751577676025","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ecole-francaise-jules-verne-de-riga\/","zoom":7,"extra_fields":{"post_excerpt":"6e et 2nd \u2022 2023-2024","post_content":"<h2>\u00c9cole fran\u00e7aise Jules Verne de Riga<\/h2>\n<p>Commune\u00a0: Riga<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>90 \u00e9l\u00e8ves de 6e et 2nd<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites Mangalsala, Kipsala et Maskavas-Fortstate. \"<ul><li><a rel=\"\"noreferrer noopener\"\" <ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-18FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-18FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-19FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-19FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/06\/PAL-23-24-AEFE-20FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"\u00c9cole fran\u00e7aise Jules Verne de Riga","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ecole-francaise-jules-verne-de-riga\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"56.98891962499646","%_wpgmp_metabox_longitude%":"24.135751577676025","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_18#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":13188,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Plage de Quebrada","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Plage de Quebrada<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Oeiras  \u20222024-2025\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nPlage de Quebrada<\/h2>\n<p>Latitude : 38.69949261631159|Longitude : -9.251818112283294<br \/>Commune : Oeiras <\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p><\/div><\/div>","content":"Oeiras  \u20222024-2025","location":{"lat":"38.69949261631159","lng":"-9.251818112283294","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-quebrada\/","zoom":7,"extra_fields":{"post_excerpt":"Oeiras  \u20222024-2025","post_content":"<h2 class=\"site\">\nPlage de Quebrada<\/h2>\n<p>Latitude : 38.69949261631159|Longitude : -9.251818112283294<br \/>Commune : Oeiras <\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p>","post_title":"Plage de Quebrada","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-quebrada\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"38.69949261631159","%_wpgmp_metabox_longitude%":"-9.251818112283294","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_4","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2024-2025"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13193,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2024-2025"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Plage d&rsquo;Alges","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Plage d&rsquo;Alges<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Alges \u2022 2024-2025\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nPlage d'Alges<\/h2>\n<p>Latitude : 38.69587113016459|Longitude : -9.230891514450324<br \/>Commune : Alges<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p><\/div><\/div>","content":"Alges \u2022 2024-2025","location":{"lat":"38.69587113016459","lng":"-9.230891514450324","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-dalges\/","zoom":7,"extra_fields":{"post_excerpt":"Alges \u2022 2024-2025","post_content":"<h2 class=\"site\">\nPlage d'Alges<\/h2>\n<p>Latitude : 38.69587113016459|Longitude : -9.230891514450324<br \/>Commune : Alges<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p>","post_title":"Plage d&rsquo;Alges","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-dalges\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"38.69587113016459","%_wpgmp_metabox_longitude%":"-9.230891514450324","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_5","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2024-2025"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13194,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2024-2025"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Plage de Trafaria","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Plage de Trafaria<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Trafaria \u2022 2024-2025\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nPlage de Trafaria<\/h2>\n<p>Latitude : 38.67132505429716|Longitude : -9.24331359690028<br \/>Commune : Trafaria<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p><\/div><\/div>","content":"Trafaria \u2022 2024-2025","location":{"lat":"38.67132505429716","lng":"-9.24331359690028","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-trafaria\/","zoom":7,"extra_fields":{"post_excerpt":"Trafaria \u2022 2024-2025","post_content":"<h2 class=\"site\">\nPlage de Trafaria<\/h2>\n<p>Latitude : 38.67132505429716|Longitude : -9.24331359690028<br \/>Commune : Trafaria<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p>","post_title":"Plage de Trafaria","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-trafaria\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"38.67132505429716","%_wpgmp_metabox_longitude%":"-9.24331359690028","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_6","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2024-2025"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13195,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2024-2025"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"LFCL","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">LFCL<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                1\u00e8re \u2022 2024-2025\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>LFCL<\/h2>\n<p>Commune\u00a0: Lisbonne<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2024-2025<\/h3>\n<h4>30 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Quebrada, d'Alges et de Trafaria. Les donn\u00e9es seront mises en ligne en mai 2025.<\/p><\/div><\/div>","content":"1\u00e8re \u2022 2024-2025","location":{"lat":"38.7244663471117","lng":"-9.162802115352974","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lfcl\/","zoom":7,"extra_fields":{"post_excerpt":"1\u00e8re \u2022 2024-2025","post_content":"<h2>LFCL<\/h2>\n<p>Commune\u00a0: Lisbonne<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2024-2025<\/h3>\n<h4>30 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Quebrada, d'Alges et de Trafaria. Les donn\u00e9es seront mises en ligne en mai 2025.<\/p>","post_title":"LFCL","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lfcl\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"38.7244663471117","%_wpgmp_metabox_longitude%":"-9.162802115352974","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_6#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2024-2025"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":13196,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2024-2025"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Helios","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Helios<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saragosse \u2022 2024-2025\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nHelios<\/h2>\n<p>Latitude : 41.658889|Longitude : -0.881389<br \/>Commune : Saragosse<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p><\/div><\/div>","content":"Saragosse \u2022 2024-2025","location":{"lat":"41.658889","lng":"-0.881389","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/helios\/","zoom":7,"extra_fields":{"post_excerpt":"Saragosse \u2022 2024-2025","post_content":"<h2 class=\"site\">\nHelios<\/h2>\n<p>Latitude : 41.658889|Longitude : -0.881389<br \/>Commune : Saragosse<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p>","post_title":"Helios","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/helios\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"41.658889","%_wpgmp_metabox_longitude%":"-0.881389","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_13","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2024-2025"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13197,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2024-2025"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"El Alma del Ebro","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">El Alma del Ebro<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saragosse \u2022 2024-2025\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nEl Alma del Ebro<\/h2>\n<p>Latitude : 41.665556|Longitude : -0.908333<br \/>Commune : Saragosse<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p><\/div><\/div>","content":"Saragosse \u2022 2024-2025","location":{"lat":"41.665556","lng":"-0.908333","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/el-alma-del-ebro\/","zoom":7,"extra_fields":{"post_excerpt":"Saragosse \u2022 2024-2025","post_content":"<h2 class=\"site\">\nEl Alma del Ebro<\/h2>\n<p>Latitude : 41.665556|Longitude : -0.908333<br \/>Commune : Saragosse<\/p>\n<h3>Ann\u00e9e 2024-2025<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2025.<\/p>","post_title":"El Alma del Ebro","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/el-alma-del-ebro\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"41.665556","%_wpgmp_metabox_longitude%":"-0.908333","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_14","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2024-2025"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13198,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2024-2025"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Berge de Zemun","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Zemun<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Belgrade \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nBerge de Zemun<\/h2>\n<p>Latitude : 44.854341|Longitude : 20.398978<br \/>Commune : Belgrade<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Belgrade \u2022 2023-2024","location":{"lat":"44.854341","lng":"20.398978","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-zemun\/","zoom":7,"extra_fields":{"post_excerpt":"Belgrade \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge de Zemun<\/h2>\n<p>Latitude : 44.854341|Longitude : 20.398978<br \/>Commune : Belgrade<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Berge de Zemun","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-zemun\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"44.854341","%_wpgmp_metabox_longitude%":"20.398978","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_1","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13208,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Berge de Belgrade","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Belgrade<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Belgrade \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nBerge de Belgrade<\/h2>\n<p>Latitude : 44.824542|Longitude : 20.495944<br \/>Commune : Belgrade<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Belgrade \u2022 2023-2024","location":{"lat":"44.824542","lng":"20.495944","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-belgrade\/","zoom":7,"extra_fields":{"post_excerpt":"Belgrade \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge de Belgrade<\/h2>\n<p>Latitude : 44.824542|Longitude : 20.495944<br \/>Commune : Belgrade<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Berge de Belgrade","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-belgrade\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"44.824542","%_wpgmp_metabox_longitude%":"20.495944","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_2","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13209,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Berge de Perilo","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Perilo<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Perilo \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nBerge de Perilo<\/h2>\n<p>Latitude : 44.681684|Longitude : 20.224847<br \/>Commune : Perilo<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Perilo \u2022 2023-2024","location":{"lat":"44.681684","lng":"20.224847","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-perilo\/","zoom":7,"extra_fields":{"post_excerpt":"Perilo \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge de Perilo<\/h2>\n<p>Latitude : 44.681684|Longitude : 20.224847<br \/>Commune : Perilo<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Berge de Perilo","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-perilo\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"44.681684","%_wpgmp_metabox_longitude%":"20.224847","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_3","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13210,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Ecole Fran\u00e7aise de Belgrade","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Ecole Fran\u00e7aise de Belgrade<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Deux classes de troisi\u00e8me \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Ecole Fran\u00e7aise de Belgrade<\/h2>\n<p>Commune\u00a0: Belgrade<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>40 \u00e9l\u00e8ves de Deux classes de troisi\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites \"Berge de Zemun\", \" Berge de Belgrade\" et \"Berge de Perilo\". <\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Deux classes de troisi\u00e8me \u2022 2023-2024","location":{"lat":"44.79282181676043","lng":"20.44516768128038","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ecole-francaise-de-belgrade\/","zoom":7,"extra_fields":{"post_excerpt":"Deux classes de troisi\u00e8me \u2022 2023-2024","post_content":"<h2>Ecole Fran\u00e7aise de Belgrade<\/h2>\n<p>Commune\u00a0: Belgrade<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>40 \u00e9l\u00e8ves de Deux classes de troisi\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites \"Berge de Zemun\", \" Berge de Belgrade\" et \"Berge de Perilo\". <\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Ecole Fran\u00e7aise de Belgrade","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ecole-francaise-de-belgrade\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"44.79282181676043","%_wpgmp_metabox_longitude%":"20.44516768128038","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_1#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":13211,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Lyc\u00e9e fran\u00e7ais International Samuel Beckett","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e fran\u00e7ais International Samuel Beckett<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                1\u00e8re Sp\u00e9 SVT \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e fran\u00e7ais International Samuel Beckett<\/h2>\n<p>Commune\u00a0: Dublin<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>12 \u00e9l\u00e8ves de 1\u00e8re Sp\u00e9 SVT<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites Plage de Killiney et la berge de Liffey.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-21FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-21FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-22FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-22FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"1\u00e8re Sp\u00e9 SVT \u2022 2023-2024","location":{"lat":"53.303837851021726","lng":"-6.229848487485397","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-francais-international-samuel-beckett\/","zoom":7,"extra_fields":{"post_excerpt":"1\u00e8re Sp\u00e9 SVT \u2022 2023-2024","post_content":"<h2>Lyc\u00e9e fran\u00e7ais International Samuel Beckett<\/h2>\n<p>Commune\u00a0: Dublin<br>Acad\u00e9mie :  AEFE<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>12 \u00e9l\u00e8ves de 1\u00e8re Sp\u00e9 SVT<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites Plage de Killiney et la berge de Liffey.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-21FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-21FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-22FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-22FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e fran\u00e7ais International Samuel Beckett","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-francais-international-samuel-beckett\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"53.303837851021726","%_wpgmp_metabox_longitude%":"-6.229848487485397","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_21#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":13192,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Plage de Killiney","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Plage de Killiney<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Killiney \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nPlage de Killiney<\/h2>\n<p>Latitude : 53.2611944|Longitude : -6.1108056<br \/>Commune : Killiney<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-21FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-21FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Killiney \u2022 2023-2024","location":{"lat":"53.2611944","lng":"-6.1108056","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-killiney\/","zoom":7,"extra_fields":{"post_excerpt":"Killiney \u2022 2023-2024","post_content":"<h2 class=\"site\">\nPlage de Killiney<\/h2>\n<p>Latitude : 53.2611944|Longitude : -6.1108056<br \/>Commune : Killiney<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-21FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-21FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Plage de Killiney","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-killiney\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"53.2611944","%_wpgmp_metabox_longitude%":"-6.1108056","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_21","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13189,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Plage de Killiney","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Plage de Killiney<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Killiney \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nPlage de Killiney<\/h2>\n<p>Latitude : 53.2550565902685|Longitude : -6.112377156200844<br \/>Commune : Killiney<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-22FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-22FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Killiney \u2022 2023-2024","location":{"lat":"53.2550565902685","lng":"-6.112377156200844","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-killiney-2\/","zoom":7,"extra_fields":{"post_excerpt":"Killiney \u2022 2023-2024","post_content":"<h2 class=\"site\">\nPlage de Killiney<\/h2>\n<p>Latitude : 53.2550565902685|Longitude : -6.112377156200844<br \/>Commune : Killiney<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-22FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-22FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Plage de Killiney","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-killiney-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"53.2550565902685","%_wpgmp_metabox_longitude%":"-6.112377156200844","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_22","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13190,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]},{"source":"post","title":"Berge de Liffey","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Liffey<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Dublin \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nBerge de Liffey<\/h2>\n<p>Latitude : 53.34720890277789|Longitude : -6.317145810993698<br \/>Commune : Dublin<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Dublin \u2022 2023-2024","location":{"lat":"53.34720890277789","lng":"-6.317145810993698","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-liffey\/","zoom":7,"extra_fields":{"post_excerpt":"Dublin \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge de Liffey<\/h2>\n<p>Latitude : 53.34720890277789|Longitude : -6.317145810993698<br \/>Commune : Dublin<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-AEFE-23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Berge de Liffey","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-liffey\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"53.34720890277789","%_wpgmp_metabox_longitude%":"-6.317145810993698","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"40\";}","%refpoint%":"PAL_23-24_AEFE_23","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":13191,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"AEFE","id":"40","type":"category"}]}],"listing":{"listing_header":"<div id=\"explicatif\" style=\"margin: 10px 10px 10px 0;\">2019 \u00e0 2024 : r\u00e9sultats&nbsp;disponibles<\/div>\r\n<div id=\"legende\"><img class=\"wp-image-520\" style=\"width: 15px; height:15px; display:inline; vertical-align:bottom;\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/06\/maker-classe.png\" alt=\"\"> Classes&nbsp;&nbsp;<img class=\"wp-image-520\" style=\"width: 15px; height:15px; display:inline; vertical-align:bottom;\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/09\/maker-site-2.png\" alt=\"\"> Sites | Filtres&nbsp;:<\/div>","display_search_form":false,"search_field_autosuggest":false,"display_category_filter":false,"display_sorting_filter":false,"display_radius_filter":false,"radius_dimension":"miles","apply_default_radius":false,"default_radius_dimension":"miles","display_location_per_page_filter":false,"display_print_option":false,"display_grid_option":false,"filters":["place_category"],"sorting_options":{"category__asc":"A-Z Category","category__desc":"Z-A Category","title__asc":"A-Z Title","title__desc":"Z-A Title","address__asc":"A-Z Address","address__desc":"Z-A Address"},"default_sorting":{"orderby":"title","inorder":"asc"},"listing_container":".location_listing3","tabs_container":".location_listing3","hide_locations":true,"filters_position":"top_map","hide_map":false,"pagination":{"listing_per_page":10},"list_grid":"wpgmp_listing_list","listing_placeholder":"<div class=\"wpgmp_locations\">\r\n<div class=\"wpgmp_locations_head\">\r\n<div class=\"wpgmp_location_title\">\r\n<a href=\"\" class=\"place_title\" data-zoom=\"{marker_zoom}\" data-marker=\"{marker_id}\">{marker_title}<\/a>\r\n<\/div>\r\n<div class=\"wpgmp_location_meta\">\r\n<span class=\"wpgmp_location_category fc-badge info\">{marker_category}<\/span>\r\n<\/div>\r\n<\/div>\r\n<div class=\"wpgmp_locations_content\">\r\n{marker_message}\r\n<\/div>\r\n<div class=\"wpgmp_locations_foot\"><\/div>\r\n<p style=\"text-align:center;\"><a href=\"{post_link}\" target=\"_self\">EN SAVOIR PLUS<\/a><\/p>\r\n<\/div>","list_item_skin":{"name":"default","type":"item","sourcecode":"&lt;div class=&quot;wpgmp_locations&quot;&gt;\r\n&lt;div class=&quot;wpgmp_locations_head&quot;&gt;\r\n&lt;div class=&quot;wpgmp_location_title&quot;&gt;\r\n&lt;a href=&quot;&quot; class=&quot;place_title&quot; data-zoom=&quot;{marker_zoom}&quot; data-marker=&quot;{marker_id}&quot;&gt;{marker_title}&lt;\/a&gt;\r\n&lt;\/div&gt;\r\n&lt;div class=&quot;wpgmp_location_meta&quot;&gt;\r\n&lt;span class=&quot;wpgmp_location_category fc-badge info&quot;&gt;{marker_category}&lt;\/span&gt;\r\n&lt;\/div&gt;\r\n&lt;\/div&gt;\r\n&lt;div class=&quot;wpgmp_locations_content&quot;&gt;\r\n{marker_message}\r\n&lt;\/div&gt;\r\n&lt;div class=&quot;wpgmp_locations_foot&quot;&gt;&lt;\/div&gt;\r\n&lt;p style=&quot;text-align:center;&quot;&gt;&lt;a href=&quot;{post_link}&quot; target=&quot;_self&quot;&gt;EN SAVOIR PLUS&lt;\/a&gt;&lt;\/p&gt;\r\n&lt;\/div&gt;"}},"map_property":{"map_id":"3","debug_mode":false},"map_marker_spiderfier_setting":{"minimum_markers":"0"},"shapes":{"drawing_editable":false},"filters":{"custom_filters":{"filters":{"dropdown":{"%type-site-classe%":"Sites et classes","%etude%":"Type de pollution","%annee%":"Ann\u00e9e"}}},"filters_container":"[data-container=\"wpgmp-filters-container\"]"},"marker_category_icons":{"1":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","2":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","3":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","4":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","5":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","6":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","7":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","8":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","9":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","10":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","11":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","12":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","13":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","14":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","15":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","16":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","17":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","18":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","19":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","20":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","21":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","22":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","23":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","24":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","25":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","26":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","27":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","28":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","29":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","30":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","31":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","32":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","33":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","34":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","35":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","36":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","37":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe-en-cours.png","38":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-en-cours.png","40":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png"}}